a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
220 return myNPbase->mueeZH(sqrt_s);
221}
222
223mueeZHPol::mueeZHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZHPol called with a class whose parent is not NPbase");
228}
229
231{
233}
234
235mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
240}
241
243{
244 return myNPbase->mueeZllH(sqrt_s);
245}
246
247mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
252}
253
255{
257}
258
259mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
264}
265
267{
268 return myNPbase->mueeZqqH(sqrt_s);
269}
270
271mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
272: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
273{
274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
275 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
276}
277
279{
281}
282
283
284aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
285: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
286{
287 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
288 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
289}
290
292{
294}
295
296
297bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
298: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
299{
300 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
301 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
302}
303
305{
307}
308
309
310muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVH(sqrt_s);
320}
321
322muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVHpT250(sqrt_s);
332}
333
334muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muVBFpVH(sqrt_s);
344}
345
346muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->muttH(sqrt_s);
356}
357
358mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->mutHq(sqrt_s);
368}
369
370muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
375}
376
378{
379 return myNPbase->muggHpttH(sqrt_s);
380}
381
382mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
383: ThObservable(SM_i), sqrt_s(sqrt_s_i)
384{
385 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
386 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
387
388}
389
391{
392 return myNPbase->mueettH(sqrt_s);
393}
394
395mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
400}
401
403{
405}
406
407mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummH(sqrt_s);
417}
418
419mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
420: ThObservable(SM_i), sqrt_s(sqrt_s_i)
421{
422 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
423 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
424}
425
427{
428 return myNPbase->mummHNWA(sqrt_s);
429}
430
432: ThObservable(SM_i)
433{
434 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
435 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
436}
437
439{
441}
442
444{
445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
446 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
447}
448
450{
451 return myNPbase->BrHtoinvRatio();
452}
453
455: ThObservable(SM_i)
456{
457 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
458 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
459}
460
462{
463 return myNPbase->Br_H_inv();
464}
465
467: ThObservable(SM_i)
468{
469 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
470 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
471}
472
474{
475 return myNPbase->Br_H_inv_NP();
476}
477
479: ThObservable(SM_i)
480{
481 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
482 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
483}
484
486{
487 return myNPbase->Br_H_exo();
488}
489
491: ThObservable(SM_i)
492{
493 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
494 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
495}
496
498{
499 return myNPbase->BrHvisRatio();
500}
501
503: ThObservable(SM_i)
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->BrHggRatio();
512}
513
515: ThObservable(SM_i)
516{
517 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
518 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
519}
520
522{
523 return myNPbase->BrHWWRatio();
524}
525
527: ThObservable(SM_i)
528{
529 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
530 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
531}
532
534{
535 return myNPbase->BrHZZRatio();
536}
537
539: ThObservable(SM_i)
540{
541 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
542 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
543}
544
546{
547 return myNPbase->BrHVVRatio();
548}
549
551{
552 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
553 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
554}
555
557{
558 return myNPbase->BrHZgaRatio();
559}
560
562{
563 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
564 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
565}
566
568{
569 return myNPbase->BrHZgallRatio();
570}
571
573{
574 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
575 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
576}
577
579{
580 return myNPbase->BrHZgaeeRatio();
581}
582
584{
585 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
586 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
587}
588
590{
591 return myNPbase->BrHZgamumuRatio();
592}
593
595{
596 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
597 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
598}
599
601{
602 return myNPbase->BrHgagaRatio();
603}
604
606{
607 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
608 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
609}
610
612{
613 return myNPbase->BrHmumuRatio();
614}
615
617{
618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
619 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
620}
621
623{
624 return myNPbase->BrHtautauRatio();
625}
626
628{
629 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
630 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
631}
632
634{
635 return myNPbase->BrHccRatio();
636}
637
639{
640 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
641 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
642}
643
645{
646 return myNPbase->BrHbbRatio();
647}
648
649// -----------------------------------------------------------------------------
650// More 4 fermion decays
651// -----------------------------------------------------------------------------
652
653
655: ThObservable(SM_i)
656{
657 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
658 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
659}
660
662{
663 return myNPbase->BrH2l2vRatio();
664}
665
666
668: ThObservable(SM_i)
669{
670 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
671 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
672}
673
675{
676 return myNPbase->BrHevmuvRatio();
677}
678
679
681: ThObservable(SM_i)
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
685}
686
688{
689 // SM decay widths (from MG simulations)
690 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
691
692 // Sum
693 double wH2e2vTSM=wH2e2vSM+wH2evSM;
694
695 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
696}
697
698
700: ThObservable(SM_i)
701{
702 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
703 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
704}
705
707{
708 // SM decay widths (from MG simulations)
709 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
710
711 // Sum
712 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
713
714 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
715}
716
717
719: ThObservable(SM_i)
720{
721 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
722 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
723}
724
726{
727 return myNPbase->BrH4lRatio();
728}
729
730
732: ThObservable(SM_i)
733{
734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
735 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
736}
737
739{
740 return myNPbase->BrH4eRatio();
741}
742
743
745: ThObservable(SM_i)
746{
747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
748 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
749}
750
752{
753 return myNPbase->BrH4muRatio();
754}
755
756
758: ThObservable(SM_i)
759{
760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
761 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
762}
763
765{
766 return myNPbase->BrH2e2muRatio();
767}
768
769
770
772: ThObservable(SM_i)
773{
774 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
775 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
776}
777
779{
780 return myNPbase->BrHlljjRatio();
781}
782
783
785: ThObservable(SM_i)
786{
787 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
788 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
789}
790
792{
793 return myNPbase->BrHlvjjRatio();
794}
795
796
798: ThObservable(SM_i)
799{
800 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
801 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
802}
803
805{
806 return myNPbase->BrHlv_lvorjjRatio();
807}
808
809
811: ThObservable(SM_i)
812{
813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
814 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
815}
816
818{
819 return myNPbase->BrHll_vvorjjRatio();
820}
821
822// -----------------------------------------------------------------------------
823// Ratios of BR (ratios with SM)
824// -----------------------------------------------------------------------------
825
827{
828 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
829 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
830}
831
833{
834 if ((this->getModel()).isModelLinearized()) {
835 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
836 } else {
837 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
838 }
839}
840
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
845}
846
848{
849 if ((this->getModel()).isModelLinearized()) {
850 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
851 } else {
852 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
853 }
854}
855
857{
858 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
859 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
860}
861
863{
864 if ((this->getModel()).isModelLinearized()) {
865 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
866 } else {
868 }
869}
870
872{
873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
874 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
875}
876
878{
879 if ((this->getModel()).isModelLinearized()) {
880 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
881 } else {
882 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
883 }
884}
885
887{
888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
889 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
890}
891
893{
894 if ((this->getModel()).isModelLinearized()) {
895 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
896 } else {
897 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
898 }
899}
900
901
903{
904 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
905 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
906}
907
909{
910 if ((this->getModel()).isModelLinearized()) {
911 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
912 } else {
913 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
914 }
915}
916
917
919{
920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
921 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
922}
923
925{
926 if ((this->getModel()).isModelLinearized()) {
927 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
928 } else {
929 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
930 }
931}
932
933
935{
936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
937 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
938}
939
941{
942 if ((this->getModel()).isModelLinearized()) {
943 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
944 } else {
945 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
946 }
947}
948
950{
951 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
952 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
953}
954
956{
957 if ((this->getModel()).isModelLinearized()) {
958 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
959 } else {
960 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
961 }
962}
963
965{
966 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
967 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
968}
969
971{
972 if ((this->getModel()).isModelLinearized()) {
973 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
974 } else {
975 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
976 }
977}
978
980{
981 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
982 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
983}
984
986{
987 if ((this->getModel()).isModelLinearized()) {
988 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
989 } else {
990 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
991 }
992}
993
995{
996 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
997 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
998}
999
1001{
1002 if ((this->getModel()).isModelLinearized()) {
1003 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1004 } else {
1005 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1006 }
1007}
1008
1010{
1011 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1012 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1013}
1014
1016{
1017 if ((this->getModel()).isModelLinearized()) {
1018 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1019 } else {
1020 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1021 }
1022}
1023
1025{
1026 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1027 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1028}
1029
1031{
1032 if ((this->getModel()).isModelLinearized()) {
1033 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1034 } else {
1035 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1036 }
1037}
1038
1039
1041{
1042 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1043 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1044}
1045
1047{
1048 if ((this->getModel()).isModelLinearized()) {
1049 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1050 } else {
1051 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1052 }
1053}
1054
1055
1057{
1058 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1059 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1060}
1061
1063{
1064 if ((this->getModel()).isModelLinearized()) {
1065 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1066 } else {
1067 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1068 }
1069}
1070
1071
1073{
1074 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1075 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1076}
1077
1079{
1080 if ((this->getModel()).isModelLinearized()) {
1081 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1082 } else {
1083 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1084 }
1085}
1086
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1098 } else {
1099 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1100 }
1101}
1102
1103
1105{
1106 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1107 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1108}
1109
1111{
1112 if ((this->getModel()).isModelLinearized()) {
1113 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1114 } else {
1115 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1116 }
1117}
1118
1119
1120// -----------------------------------------------------------------------------
1121// Full signal strengths (prod x decay)
1122// -----------------------------------------------------------------------------
1123
1124muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1125: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1126{
1127 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1128 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1129}
1130
1132{
1133 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1134 //AG: Most general expression including quadratic corrections.
1135 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1136 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1137 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1138 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1139 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1140 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1141
1142 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1143 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1144 double Br1 = dGammaR1-dGammaRTot1;
1145 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1146 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1147 } else {
1148 return myNPbase->muggHgaga(sqrt_s);
1149 }
1150}
1151
1152muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1153: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1154{
1155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1156 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1157}
1158
1160{
1162}
1163
1164muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1166{
1167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1168 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1169}
1170
1172{
1173 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1174 //AG: Most general expression including quadratic corrections.
1175 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1176 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1177 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1178 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1179 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1180 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1181
1182 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1183 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1184 double Br1 = dGammaR1-dGammaRTot1;
1185 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1186
1187 double mu;
1188
1189 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1190
1191 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1192
1193 return mu;
1194 } else {
1195 return myNPbase->muVBFHgaga(sqrt_s);
1196 }
1197}
1198
1199muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1200: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1201{
1202 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1203 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1204}
1205
1207{
1208 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1209 //AG: Most general expression including quadratic corrections.
1210 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1211 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1212 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1213 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1214 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1215 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1216
1217 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1218 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1219 double Br1 = dGammaR1-dGammaRTot1;
1220 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1221
1222 double mu;
1223
1224 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1225
1226 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1227
1228 return mu;
1229
1230 } else {
1231 return myNPbase->muZHgaga(sqrt_s);
1232 }
1233}
1234
1235muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1236: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1237{
1238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1239 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1240}
1241
1243{
1244 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1245 //AG: Most general expression including quadratic corrections.
1246 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1247 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1248 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1249 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1250 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1251 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1252
1253 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1254 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1255 double Br1 = dGammaR1-dGammaRTot1;
1256 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1257
1258 double mu;
1259
1260 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1261
1262 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1263
1264 return mu;
1265
1266 } else {
1267 return myNPbase->muWHgaga(sqrt_s);
1268 }
1269}
1270
1271muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1272: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1273{
1274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1275 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1276}
1277
1279{
1280 if ((this->getModel()).isModelLinearized()) {
1281 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1282 } else {
1283 return myNPbase->muVHgaga(sqrt_s);
1284 }
1285}
1286
1287muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1288: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1289{
1290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1291 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1292}
1293
1295{
1296 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1297 //AG: Most general expression including quadratic corrections.
1298 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1299 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1300 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1301 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1302 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1303 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1304
1305 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1306 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1307 double Br1 = dGammaR1-dGammaRTot1;
1308 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1309
1310 double mu;
1311
1312 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1313
1314 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1315
1316 return mu;
1317
1318 } else {
1319 return myNPbase->muttHgaga(sqrt_s);
1320 }
1321}
1322
1323mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1324: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1325{
1326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1327 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1328}
1329
1331{
1332 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1333 //AG: Most general expression including quadratic corrections.
1334 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1335 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1336 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1337 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1338 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1339
1340 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1341 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1342 double Br1 = dGammaR1-dGammaRTot1;
1343 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1344
1345 double mu;
1346
1347 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1348
1349 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1350
1351 return mu;
1352
1353 } else {
1354 //VM: Just in case someone wants to add directly the production*decay
1355 //(which is the observable we fit at the end)
1356 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1357 if(NPmutHgaga==1.0){
1358 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1359 } else{
1360 return NPmutHgaga;
1361 }
1362 }
1363}
1364
1365muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1367{
1368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1369 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1370}
1371
1373{
1374 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1375 //AG: Most general expression including quadratic corrections.
1376 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1377 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1378 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1379 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1380 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1381
1382 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1383 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1384 double Br1 = dGammaR1-dGammaRTot1;
1385 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1386
1387 double mu;
1388
1389 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1390
1391 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1392
1393 return mu;
1394
1395 } else {
1396 //VM: Just in case someone wants to add directly the production*decay
1397 //(which is the observable we fit at the end)
1398 //Also, the bbH is missing here, I'll leave it as it was for the
1399 //moment (since bbH is really suppressed).
1400 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1401 if (NPmuggHpbbH_Hgaga == 1.0){
1402 return (myNPbase->muggHgaga(sqrt_s));
1403 } else{
1404 return NPmuggHpbbH_Hgaga;
1405 }
1406 }
1407}
1408
1409muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1410: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1411{
1412 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1413 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1414}
1415
1417{
1418 //VM:Note that these values are valid for 13 TeV, they are not general
1419 //We should access the SM function that has all the values (for the
1420 //different energies). The values are slightly different, we should
1421 //check this.
1422 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1423 double xsSM_ttH = 0.499873;
1424 double xsSM_tH = 0.0821;
1425 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1426 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1427
1428 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1429 //AG: Most general expression including quadratic corrections.
1430 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1431 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1432 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1433 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1434 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1435
1436 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1437 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1438 double Br1 = dGammaR1-dGammaRTot1;
1439 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1440
1441 double mu;
1442
1443 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1444
1445 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1446
1447 return mu;
1448
1449 } else {
1450 //VM: Just in case someone wants to add directly the production*decay
1451 //(which is the observable we fit at the end)
1452 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1453 if(NPmuttHptH_Hgaga==1.0){
1454 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1455 } else {
1456 return NPmuttHptH_Hgaga;
1457 }
1458 }
1459}
1460
1461muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1462: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1463{
1464 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1465 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1466}
1467
1469{
1470 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1471 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1472 //AG: Most general expression including quadratic corrections.
1473 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1474 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1475 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1476 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1477 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1478
1479 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1480 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1483
1484 double mu;
1485
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1487
1488 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1489
1490 return mu;
1491
1492 } else {
1493 return myNPbase->muggHZga(sqrt_s);
1494 }
1495}
1496
1497muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1498: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1499{
1500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1501 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1502}
1503
1505{
1506 if ((this->getModel()).isModelLinearized()) {
1507 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1508 } else {
1510 }
1511}
1512
1513muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1514: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1515{
1516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1517 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1518}
1519
1521{
1522 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1523 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1524 //AG: Most general expression including quadratic corrections.
1525 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1526 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1527 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1528 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1529 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1530
1531 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1532 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1533 double Br1 = dGammaR1-dGammaRTot1;
1534 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1535
1536 double mu;
1537
1538 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1539
1540 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1541
1542 return mu;
1543
1544 } else {
1545 return myNPbase->muVBFHZga(sqrt_s);
1546 }
1547}
1548
1549muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1550: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1551{
1552 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1553 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1554}
1555
1557{
1558 if ((this->getModel()).isModelLinearized()) {
1559 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1560 } else {
1561 return myNPbase->muZHZga(sqrt_s);
1562 }
1563}
1564
1565muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1566: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1567{
1568 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1569 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1570}
1571
1573{
1574 if ((this->getModel()).isModelLinearized()) {
1575 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1576 } else {
1577 return myNPbase->muWHZga(sqrt_s);
1578 }
1579}
1580
1581muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1582: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1583{
1584 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1585 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1586}
1587
1589{
1590 if ((this->getModel()).isModelLinearized()) {
1591 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1592 } else {
1593 return myNPbase->muVHZga(sqrt_s);
1594 }
1595}
1596
1597muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1598: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1599{
1600 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1601 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1602}
1603
1605{
1606 if ((this->getModel()).isModelLinearized()) {
1607 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1608 } else {
1609 return myNPbase->muttHZga(sqrt_s);
1610 }
1611}
1612
1613muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1614: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1615{
1616 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1617 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1618}
1619
1621{
1622 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1623 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1624 //AG: Most general expression including quadratic corrections.
1625 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1626 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1627 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1628 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1629 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1630
1631 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1632 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1633 double Br1 = dGammaR1-dGammaRTot1;
1634 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1635
1636 double mu;
1637
1638 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1639
1640 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1641
1642 return mu;
1643
1644 } else {
1645 return myNPbase->muggHZZ(sqrt_s);
1646 }
1647}
1648
1649muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1650: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1651{
1652 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1653 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1654}
1655
1657{
1658 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1659 //AG: Most general expression including quadratic corrections.
1660 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1661 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1662 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1663 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1664 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1665 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1666
1667 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1668 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1669 double Br1 = dGammaR1-dGammaRTot1;
1670 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1671
1672 double mu;
1673
1674 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1675
1676 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1677
1678 return mu;
1679
1680 } else {
1681 return myNPbase->muVBFHZZ(sqrt_s);
1682 }
1683}
1684
1685muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1686: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1687{
1688 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1689 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1690}
1691
1693{
1694 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1695 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1696 //AG: Most general expression including quadratic corrections.
1697 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1698 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1699 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1700 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1701 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1702
1703 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1704 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1705 double Br1 = dGammaR1-dGammaRTot1;
1706 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1707
1708 double mu;
1709
1710 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1711
1712 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1713
1714 return mu;
1715
1716 } else {
1717 return myNPbase->muZHZZ(sqrt_s);
1718 }
1719}
1720
1721muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1722: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1723{
1724 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1725 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1726}
1727
1729{
1730 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1731 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1732 //AG: Most general expression including quadratic corrections.
1733 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1734 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1735 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1736 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1737 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1738
1739 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1740 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1741 double Br1 = dGammaR1-dGammaRTot1;
1742 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1743
1744 double mu;
1745
1746 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1747
1748 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1749
1750 return mu;
1751
1752 } else {
1753 return myNPbase->muWHZZ(sqrt_s);
1754 }
1755}
1756
1757muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1758: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1759{
1760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1761 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1762}
1763
1765{
1766 //VM:Note that these values are valid for 13 TeV, they are not general
1767 //We should access the SM function that has all the values (for the
1768 //different energies). The values are slightly different, we should
1769 //check this.
1770 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1771 double xsSM_WH = 1.21539;
1772 double xsSM_ZH = 0.795910;
1773 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1774 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1775 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1776 //AG: Most general expression including quadratic corrections.
1777 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1778 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1779 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1780 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1781 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1782 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1783
1784 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1785 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1786 double Br1 = dGammaR1-dGammaRTot1;
1787 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1788
1789 double mu;
1790
1791 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1792
1793 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1794
1795 return mu;
1796
1797 } else {
1798 //return myNPbase->muVHZZ(sqrt_s);
1799 //VM: Just in case someone wants to add directly the production*decay
1800 //(which is the observable we fit at the end)
1801 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1802 if(NPmuVHZZ==1.0){
1803 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1804 } else {
1805 return NPmuVHZZ;
1806 }
1807 }
1808}
1809
1810muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1811: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1812{
1813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1814 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1815}
1816
1818{
1819 if ((this->getModel()).isModelLinearized()) {
1820 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1821 } else {
1822 return myNPbase->muttHZZ(sqrt_s);
1823 }
1824}
1825
1826muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1827: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1828{
1829 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1830 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1831}
1832
1834{
1835 //VM:Note that these values are valid for 13 TeV, they are not general
1836 //We should access the SM function that has all the values (for the
1837 //different energies). The values are slightly different, we should
1838 //check this.
1839 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1840 double xsSM_ttH = 0.499873;
1841 double xsSM_tH = 0.0821;
1842 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1843 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1844 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1845 //AG: Most general expression including quadratic corrections.
1846 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1847 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1848 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1849 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1850 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1851 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1852
1853 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1854 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1855 double Br1 = dGammaR1-dGammaRTot1;
1856 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1857
1858 double mu;
1859
1860 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1861
1862 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1863
1864 return mu;
1865
1866 } else {
1867
1868 //VM: Just in case someone wants to add directly the production*decay
1869 //(which is the observable we fit at the end)
1870 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
1871 if(NPmuttHptH_HZZ==1.0){
1872 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
1873 } else {
1874 return NPmuttHptH_HZZ;
1875 }
1876 }
1877}
1878
1879muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1880: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1881{
1882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1883 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
1884}
1885
1887{
1888 //VM:Note that these values are valid for 13 TeV, they are not general
1889 //We should access the SM function that has all the values (for the
1890 //different energies). The values are slightly different, we should
1891 //check this.
1892 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1893 double xsSM_ttH = 0.499873;
1894 double xsSM_tH = 0.0821;
1895 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1896 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1897 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1898 //return ( 1.0
1899 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
1900 // + (myNPbase->BrHmumuRatio()-1.));
1901 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
1902 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1903 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
1904 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
1905
1906 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1907 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1908 double Br1 = dGammaR1-dGammaRTot1;
1909 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1910
1911 double mu;
1912
1913 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1914
1915 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1916
1917 return mu;
1918
1919 } else {
1920
1921 //VM: Just in case someone wants to add directly the production*decay
1922 //(which is the observable we fit at the end)
1923 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
1924 if(NPmuttHptH_Hmumu==1.0){
1925 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
1926 } else {
1927 return NPmuttHptH_Hmumu;
1928 }
1929 }
1930}
1931
1932muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1933: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1934{
1935 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1936 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
1937}
1938
1940{
1941 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1942 //AG: Most general expression including quadratic corrections.
1943 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1944 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
1945 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1946 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1947 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1948 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1949
1950 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1951 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1952 double Br1 = dGammaR1-dGammaRTot1;
1953 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1954
1955 double mu;
1956
1957 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1958
1959 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1960
1961 return mu;
1962
1963 } else {
1964 //VM: Just in case someone wants to add directly the production*decay
1965 //(which is the observable we fit at the end)
1966 //Also, the bbH is missing here, I'll leave it as it was for the
1967 //moment (since bbH is really suppressed in the SM).
1968 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
1969 if (NPmuggHpbbH_HZZ == 1.0){
1970 return (myNPbase->muggHZZ(sqrt_s));
1971 } else{
1972 return NPmuggHpbbH_HZZ;
1973 }
1974 }
1975}
1976
1977muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1978: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1979{
1980 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1981 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
1982}
1983
1985{
1986 if ((this->getModel()).isModelLinearized()) {
1987 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1988 } else {
1989 return myNPbase->muggHZZ4l(sqrt_s);
1990 }
1991}
1992
1993muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
1994: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1995{
1996 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1997 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
1998}
1999
2001{
2002 if ((this->getModel()).isModelLinearized()) {
2003 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2004 } else {
2005 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2006 }
2007}
2008
2009muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2010: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2011{
2012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2013 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2014}
2015
2017{
2018 if ((this->getModel()).isModelLinearized()) {
2019 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2020 } else {
2021 return myNPbase->muVBFHZZ4l(sqrt_s);
2022 }
2023}
2024
2025muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2026: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2027{
2028 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2029 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2030}
2031
2033{
2034 if ((this->getModel()).isModelLinearized()) {
2035 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2036 } else {
2037 return myNPbase->muZHZZ4l(sqrt_s);
2038 }
2039}
2040
2041muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2042: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2043{
2044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2045 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2046}
2047
2049{
2050 if ((this->getModel()).isModelLinearized()) {
2051 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2052 } else {
2053 return myNPbase->muWHZZ4l(sqrt_s);
2054 }
2055}
2056
2057muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2058: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2059{
2060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2061 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2062}
2063
2065{
2066 if ((this->getModel()).isModelLinearized()) {
2067 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2068 } else {
2069 return myNPbase->muVHZZ4l(sqrt_s);
2070 }
2071}
2072
2073muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2074: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2075{
2076 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2077 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2078}
2079
2081{
2082 if ((this->getModel()).isModelLinearized()) {
2083 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2084 } else {
2085 return myNPbase->muttHZZ4l(sqrt_s);
2086 }
2087}
2088
2089muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2090: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2091{
2092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2093 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2094}
2095
2097{
2098 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2099 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2100 //AG: Most general expression including quadratic corrections.
2101 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2102 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2103 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2104 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2105 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2106
2107 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2108 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2109 double Br1 = dGammaR1-dGammaRTot1;
2110 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2111
2112 double mu;
2113
2114 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2115
2116 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2117
2118 return mu;
2119
2120 } else {
2121 return myNPbase->muggHWW(sqrt_s);
2122 }
2123}
2124
2125muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2126: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2127{
2128 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2129 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2130}
2131
2133{
2134 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2135 //AG: Most general expression including quadratic corrections.
2136 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2137 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2138 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2139 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2140 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2141 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2142
2143 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2144 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2145 double Br1 = dGammaR1-dGammaRTot1;
2146 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2147
2148 double mu;
2149
2150 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2151
2152 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2153
2154 return mu;
2155
2156 } else {
2157 return myNPbase->muVBFHWW(sqrt_s);
2158 }
2159}
2160
2161muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2162: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2163{
2164 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2165 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2166}
2167
2169{
2170 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2171 //AG: Most general expression including quadratic corrections.
2172 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2173 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2174 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2175 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2176 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2177 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2178
2179 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2180 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2181 double Br1 = dGammaR1-dGammaRTot1;
2182 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2183
2184 double mu;
2185
2186 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2187
2188 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2189
2190 return mu;
2191
2192 } else {
2193 return myNPbase->muZHWW(sqrt_s);
2194 }
2195}
2196
2197muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2198: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2199{
2200 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2201 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2202}
2203
2205{
2206 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2207 //AG: Most general expression including quadratic corrections.
2208 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2209 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2210 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2211 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2212 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2213 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2214
2215 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2216 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2217 double Br1 = dGammaR1-dGammaRTot1;
2218 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2219
2220 double mu;
2221
2222 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2223
2224 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2225
2226 return mu;
2227
2228 } else {
2229 return myNPbase->muWHWW(sqrt_s);
2230 }
2231}
2232
2233muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2234: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2235{
2236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2237 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2238}
2239
2241{
2242 if ((this->getModel()).isModelLinearized()) {
2243 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2244 } else {
2245 return myNPbase->muVHWW(sqrt_s);
2246 }
2247}
2248
2249muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2250: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2251{
2252 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2253 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2254}
2255
2257{
2258 if ((this->getModel()).isModelLinearized()) {
2259 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2260 } else {
2261 return myNPbase->muttHWW(sqrt_s);
2262 }
2263}
2264
2265muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2266: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2267{
2268 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2269 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2270}
2271
2273{
2274
2275 //VM:Note that these values are valid for 13 TeV, they are not general
2276 //We should access the SM function that has all the values (for the
2277 //different energies). The values are slightly different, we should
2278 //check this.
2279 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2280 double xsSM_ttH = 0.499873;
2281 double xsSM_tH = 0.0821;
2282 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2283 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2284 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2285 //AG: Most general expression including quadratic corrections.
2286 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2287 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2288 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2289 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2290 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2291
2292 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2293 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2294 double Br1 = dGammaR1-dGammaRTot1;
2295 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2296
2297 double mu;
2298
2299 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2300
2301 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2302
2303 return mu;
2304
2305 } else {
2306
2307 //VM: Just in case someone wants to add directly the production*decay
2308 //(which is the observable we fit at the end)
2309 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2310 if(NPmuttHptH_HWW==1.0){
2311 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2312 } else {
2313 return NPmuttHptH_HWW;
2314 }
2315 }
2316}
2317
2318muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2319: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2320{
2321 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2322 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2323}
2324
2326{
2327 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2328 //AG: Most general expression including quadratic corrections.
2329 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2330 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2331 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2332 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2333 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2334 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2335
2336 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2337 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2338 double Br1 = dGammaR1-dGammaRTot1;
2339 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2340
2341 double mu;
2342
2343 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2344
2345 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2346
2347 return mu;
2348
2349 } else {
2350
2351 //VM: Just in case someone wants to add directly the production*decay
2352 //(which is the observable we fit at the end)
2353 //Also, the bbH is missing here, I'll leave it as it was for the
2354 //moment (since bbH is really suppressed in the SM).
2355 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2356 if (NPmuggHpbbH_HWW == 1.0){
2357 return (myNPbase->muggHWW(sqrt_s));
2358 } else{
2359 return NPmuggHpbbH_HWW;
2360 }
2361 }
2362}
2363
2364muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2365: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2366{
2367 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2368 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2369}
2370
2372{
2373 if ((this->getModel()).isModelLinearized()) {
2374 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2375 } else {
2376 return myNPbase->muggHWW2l2v(sqrt_s);
2377 }
2378}
2379
2380muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2381: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2382{
2383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2384 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2385}
2386
2388{
2389 if ((this->getModel()).isModelLinearized()) {
2390 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2391 } else {
2392 return myNPbase->muVBFHWW2l2v(sqrt_s);
2393 }
2394}
2395
2396muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2397: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2398{
2399 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2400 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2401}
2402
2404{
2405 if ((this->getModel()).isModelLinearized()) {
2406 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2407 } else {
2408 return myNPbase->muZHWW2l2v(sqrt_s);
2409 }
2410}
2411
2412muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2413: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2414{
2415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2416 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2417}
2418
2420{
2421 if ((this->getModel()).isModelLinearized()) {
2422 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2423 } else {
2424 return myNPbase->muWHWW2l2v(sqrt_s);
2425 }
2426}
2427
2428muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2429: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2430{
2431 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2432 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2433}
2434
2436{
2437 if ((this->getModel()).isModelLinearized()) {
2438 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2439 } else {
2440 return myNPbase->muVHWW2l2v(sqrt_s);
2441 }
2442}
2443
2444muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2445: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2446{
2447 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2448 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2449}
2450
2452{
2453 if ((this->getModel()).isModelLinearized()) {
2454 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2455 } else {
2456 return myNPbase->muttHWW2l2v(sqrt_s);
2457 }
2458}
2459
2460muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2461: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2462{
2463 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2464 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2465}
2466
2468{
2469 if ((this->getModel()).isModelLinearized()) {
2470 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2471 } else {
2472 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2473 }
2474}
2475
2476muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2477: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2478{
2479 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2480 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2481}
2482
2484{
2485 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2486 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2487 //AG: Most general expression including quadratic corrections.
2488 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2489 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2490 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2491 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2492 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2493
2494 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2495 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2496 double Br1 = dGammaR1-dGammaRTot1;
2497 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2498
2499 double mu;
2500
2501 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2502
2503 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2504
2505 return mu;
2506
2507 } else {
2508 return myNPbase->muggHmumu(sqrt_s);
2509 }
2510}
2511
2512muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2513: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2514{
2515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2516 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2517}
2518
2520{
2521 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2522 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2523 //AG: Most general expression including quadratic corrections.
2524 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2525 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2526 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2527 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2528 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2529
2530 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2531 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2532 double Br1 = dGammaR1-dGammaRTot1;
2533 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2534
2535 double mu;
2536
2537 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2538
2539 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2540
2541 return mu;
2542
2543 } else {
2544 return myNPbase->muVBFHmumu(sqrt_s);
2545 }
2546}
2547
2548muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2549: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2550{
2551 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2552 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2553}
2554
2556{
2557 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2558 //AG: Most general expression including quadratic corrections.
2559 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2560 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2561 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2562 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2563 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2564
2565 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2566 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2567 double Br1 = dGammaR1-dGammaRTot1;
2568 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2569
2570 double mu;
2571
2572 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2573
2574 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2575
2576 return mu;
2577
2578 } else {
2579 return myNPbase->muZHmumu(sqrt_s);
2580 }
2581}
2582
2583muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2584: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2585{
2586 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2587 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2588}
2589
2591{
2592 if ((this->getModel()).isModelLinearized()) {
2593 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2594 } else {
2595 return myNPbase->muWHmumu(sqrt_s);
2596 }
2597}
2598
2599muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2600: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2601{
2602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2603 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2604}
2605
2607{
2608
2609 //VM:Note that these values are valid for 13 TeV, they are not general
2610 //We should access the SM function that has all the values (for the
2611 //different energies). The values are slightly different, we should
2612 //check this.
2613 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2614 double xsSM_WH = 1.21539;
2615 double xsSM_ZH = 0.795910;
2616 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2617 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2618 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2619 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2620 //AG: Most general expression including quadratic corrections.
2621 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2622 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2623 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2624 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2625 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2626
2627 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2628 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2629 double Br1 = dGammaR1-dGammaRTot1;
2630 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2631
2632 double mu;
2633
2634 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2635
2636 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2637
2638 return mu;
2639
2640 } else {
2641 //return myNPbase->muVHmumu(sqrt_s);
2642 //VM: Just in case someone wants to add directly the production*decay
2643 //(which is the observable we fit at the end)
2644 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2645 if(NPmuVHmumu==1.0){
2646 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2647 } else {
2648 return NPmuVHmumu;
2649 }
2650
2651 }
2652}
2653
2654muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2655: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2656{
2657 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2658 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2659}
2660
2662{
2663 if ((this->getModel()).isModelLinearized()) {
2664 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2665 } else {
2666 return myNPbase->muttHmumu(sqrt_s);
2667 }
2668}
2669
2670muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2671: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2672{
2673 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2674 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2675}
2676
2678{
2679 //VM:Note that these values are valid for 13 TeV, they are not general
2680 //We should access the SM function that has all the values (for the
2681 //different energies). The values are slightly different, we should
2682 //check this. Furthermore, the bbH is not included. In the SM this is
2683 //very suppressed (and it's probably also the case in the SMEFT) but
2684 //in some NP models it may not be the case.Unfortunately, bbH is not
2685 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2686 //SMEFT and add here the general expression.
2687 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2688 double xsSM_ggHbbH = 44.745;
2689 double xsSM_ttH = 0.4998;
2690 double xsSM_tH = 0.084769;
2691 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2692 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2693 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2694 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2695
2696
2697
2698 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2699 //AG: Most general expression including quadratic corrections.
2700 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2701 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2702 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2703 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2704 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2705
2706 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2707 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2708 double Br1 = dGammaR1-dGammaRTot1;
2709 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2710
2711 double mu;
2712
2713 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2714
2715 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2716
2717 return mu;
2718
2719 } else {
2720
2721 //VM: Just in case someone wants to add directly the production*decay
2722 //(which is the observable we fit at the end). Furthermore, the Hbb
2723 //is not added in the original formula, fine for the SM (probably also
2724 //for the SMEFT) but not for all NP models.
2725 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2726 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2727 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2728 } else {
2729 return NPmuggHpttHptHpbbH_Hmumu;
2730 }
2731 }
2732}
2733
2734muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2735: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2736{
2737 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2738 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2739}
2740
2742{
2743
2744 //VM:Note that these values are valid for 13 TeV, they are not general
2745 //We should access the SM function that has all the values (for the
2746 //different energies). The values are slightly different, we should
2747 //check this.
2748 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2749 double xsSM_VBF = 3.49948;
2750 double xsSM_WH = 1.21539;
2751 double xsSM_ZH = 0.795910;
2752 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2753 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2754 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2755 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2756 //AG: Most general expression including quadratic corrections.
2757 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2758 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2759 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2760 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2761 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2762
2763 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2764 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2765 double Br1 = dGammaR1-dGammaRTot1;
2766 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2767
2768 double mu;
2769
2770 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2771
2772 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2773
2774 return mu;
2775
2776 } else {
2777
2778 //VM: Just in case someone wants to add directly the production*decay
2779 //(which is the observable we fit at the end).
2780 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2781 if(NPmuVBFpVH_Hmumu==1.0){
2782 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2783 } else {
2784 return NPmuVBFpVH_Hmumu;
2785 }
2786 }
2787}
2788
2789muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2790: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2791{
2792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2793 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2794}
2795
2797{
2798 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2799 //AG: Most general expression including quadratic corrections.
2800 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2801 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2802 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2803 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2804 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2805 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2806
2807 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2808 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2809 double Br1 = dGammaR1-dGammaRTot1;
2810 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2811
2812 double mu;
2813
2814 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2815
2816 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2817
2818 return mu;
2819
2820 } else {
2821 return myNPbase->muggHtautau(sqrt_s);
2822 }
2823}
2824
2825muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2826: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2827{
2828 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2829 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2830}
2831
2833{
2834 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2835 //AG: Most general expression including quadratic corrections.
2836 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2837 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2838 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2839 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2840 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2841 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2842
2843 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2844 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2845 double Br1 = dGammaR1-dGammaRTot1;
2846 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2847
2848 double mu;
2849
2850 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2851
2852 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2853
2854 return mu;
2855
2856 } else {
2857 return myNPbase->muVBFHtautau(sqrt_s);
2858 }
2859}
2860
2861
2862
2863muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2864: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2865{
2866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2867 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
2868}
2869
2871{
2872 if ((this->getModel()).isModelLinearized()) {
2873 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2874 } else {
2876 }
2877}
2878
2879
2880muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2881: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2882{
2883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2884 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
2885}
2886
2887double muZHtautau::computeThValue() //AG:modified
2888{
2889 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2890 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2891 //AG: Most general expression including quadratic corrections.
2892 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2893 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2894 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2895 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2896 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2897 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2898
2899 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2900 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2901 double Br1 = dGammaR1-dGammaRTot1;
2902 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2903
2904 double mu;
2905
2906 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2907
2908 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2909
2910 return mu;
2911
2912 } else {
2913 return myNPbase->muZHtautau(sqrt_s);
2914 }
2915}
2916
2917muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2918: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2919{
2920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2921 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
2922}
2923
2925{
2926 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2927 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2928 //AG: Most general expression including quadratic corrections.
2929 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2930 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2931 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2932 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2933 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2934
2935 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2936 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2937 double Br1 = dGammaR1-dGammaRTot1;
2938 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2939
2940 /*std::cout << "muProd1="<<muProd1<<std::endl;
2941 std::cout << "muProd2="<<muProd2<<std::endl;
2942 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
2943 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
2944 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
2945 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
2946
2947 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
2948 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
2949
2950 double mu;
2951
2952 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2953
2954 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2955
2956 return mu;
2957
2958 } else {
2959 return myNPbase->muWHtautau(sqrt_s);
2960 }
2961}
2962
2963muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2964: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2965{
2966 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2967 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
2968}
2969
2971{
2972 //VM:Note that these values are valid for 13 TeV, they are not general
2973 //We should access the SM function that has all the values (for the
2974 //different energies). The values are slightly different, we should
2975 //check this.
2976 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2977 double xsSM_WH = 1.21539;
2978 double xsSM_ZH = 0.795910;
2979 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2980 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2981 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2982 //AG: Most general expression including quadratic corrections.
2983 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2984 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2985 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2986 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2987 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2988 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2989
2990 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2991 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2992 double Br1 = dGammaR1-dGammaRTot1;
2993 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2994
2995 double mu;
2996
2997 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2998
2999 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3000
3001 return mu;
3002
3003 } else {
3004 //return myNPbase->muVHtautau(sqrt_s);
3005
3006 //VM: Just in case someone wants to add directly the production*decay
3007 //(which is the observable we fit at the end)
3008 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3009 if(NPmuVHtautau==1.0){
3010 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3011 } else {
3012 return NPmuVHtautau;
3013 }
3014 }
3015}
3016
3017muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3018: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3019{
3020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3021 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3022}
3023
3025{
3026 if ((this->getModel()).isModelLinearized()) {
3027 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3028 } else {
3029 return myNPbase->muttHtautau(sqrt_s);
3030 }
3031}
3032
3033muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3034: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3035{
3036 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3037 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3038}
3039
3041{
3042 //VM:Note that these values are valid for 13 TeV, they are not general
3043 //We should access the SM function that has all the values (for the
3044 //different energies). The values are slightly different, we should
3045 //check this.
3046 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3047 double xsSM_ttH = 0.499873;
3048 double xsSM_tH = 0.0821;
3049 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3050 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3051 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3052 //AG: Most general expression including quadratic corrections.
3053 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3054 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3055 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3056 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3057 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3058
3059 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3060 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3061 double Br1 = dGammaR1-dGammaRTot1;
3062 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3063
3064 double mu;
3065
3066 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3067
3068 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3069
3070 return mu;
3071
3072 } else {
3073
3074 //VM: Just in case someone wants to add directly the production*decay
3075 //(which is the observable we fit at the end)
3076 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3077 if(NPmuttHptH_Htautau==1.0){
3078 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3079 } else {
3080 return NPmuttHptH_Htautau;
3081 }
3082
3083 }
3084}
3085
3086muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3088{
3089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3090 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3091}
3092
3094{
3095 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3096 //AG: Most general expression including quadratic corrections.
3097 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3098 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3099 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3100 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3101 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3102 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3103
3104 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3105 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3106 double Br1 = dGammaR1-dGammaRTot1;
3107 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3108
3109 double mu;
3110
3111 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3112
3113 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3114
3115 return mu;
3116
3117 } else {
3118
3119 //VM: Just in case someone wants to add directly the production*decay
3120 //(which is the observable we fit at the end)
3121 //Also, the bbH is missing here, I'll leave it as it was for the
3122 //moment (since bbH is really suppressed in the SM).
3123 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3124 if (NPmuggHpbbH_Htautau == 1.0){
3125 return (myNPbase->muggHtautau(sqrt_s));
3126 } else{
3127 return NPmuggHpbbH_Htautau;
3128 }
3129 }
3130}
3131
3132muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3133: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3134{
3135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3136 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3137}
3138
3140{
3141 if ((this->getModel()).isModelLinearized()) {
3142 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3143 //AG: Most general expression including quadratic corrections.
3144 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3145 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3146 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3147 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3148 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3149
3150 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3151 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3152 double Br1 = dGammaR1-dGammaRTot1;
3153 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3154
3155 double mu;
3156
3157 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3158
3159 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3160
3161 return mu;
3162
3163 } else {
3164 return myNPbase->muggHbb(sqrt_s);
3165 }
3166}
3167
3168muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3169: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3170{
3171 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3172 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3173}
3174
3176{
3177 if ((this->getModel()).isModelLinearized()) {
3178 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3179 } else {
3180 return myNPbase->muVBFHbb(sqrt_s);
3181 }
3182}
3183
3184muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3185: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3186{
3187 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3188 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3189}
3190
3192{
3193 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3194 //AG: Most general expression including quadratic corrections.
3195 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3196 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3197 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3198 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3199 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3200 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3201
3202 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3203 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3204 double Br1 = dGammaR1-dGammaRTot1;
3205 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3206
3207 double mu;
3208
3209 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3210
3211 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3212
3213 return mu;
3214
3215 } else {
3216 return myNPbase->muZHbb(sqrt_s);
3217 }
3218}
3219
3220muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3221: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3222{
3223 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3224 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3225}
3226
3228{
3229 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3230 //AG: Most general expression including quadratic corrections.
3231 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3232 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3233 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3234 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3235 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3236 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3237
3238 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3239 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3240 double Br1 = dGammaR1-dGammaRTot1;
3241 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3242
3243 double mu;
3244
3245 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3246
3247 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3248
3249 return mu;
3250
3251 } else {
3252 return myNPbase->muWHbb(sqrt_s);
3253 }
3254}
3255
3256muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3257: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3258{
3259 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3260 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3261}
3262
3264{
3265 if ((this->getModel()).isModelLinearized()) {
3266 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3267 } else {
3268 return myNPbase->muVHbb(sqrt_s);
3269 }
3270}
3271
3272muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3273: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3274{
3275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3276 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3277}
3278
3280{
3281 if ((this->getModel()).isModelLinearized()) {
3282 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3283 } else {
3284 return myNPbase->muttHbb(sqrt_s);
3285 }
3286}
3287
3288muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3289: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3290{
3291 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3292 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3293}
3294
3296{
3297 //VM:Note that these values are valid for 13 TeV, they are not general
3298 //We should access the SM function that has all the values (for the
3299 //different energies). The values are slightly different, we should
3300 //check this.
3301 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3302 double xsSM_ttH = 0.499873;
3303 double xsSM_tH = 0.0821;
3304 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3305 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3306 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3307 //AG: Most general expression including quadratic corrections.
3308 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3309 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3310 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3311 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3312 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3313
3314 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3315 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3316 double Br1 = dGammaR1-dGammaRTot1;
3317 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3318
3319 double mu;
3320
3321 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3322
3323 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3324
3325 return mu;
3326
3327 } else {
3328
3329
3330 //VM: Just in case someone wants to add directly the production*decay
3331 //(which is the observable we fit at the end)
3332 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3333 if(NPmuttHptH_Hbb==1.0){
3334 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3335 } else {
3336 return NPmuttHptH_Hbb;
3337 }
3338 }
3339}
3340
3341muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3342: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3343{
3344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3345 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3346}
3347
3349{
3350 //VM:Note that these values are valid for 13 TeV, they are not general
3351 //We should access the SM function that has all the values (for the
3352 //different energies). The values are slightly different, we should
3353 //check this. Furthermore, the bbH is not included. In the SM this is
3354 //very suppressed (and it's probably also the case in the SMEFT) but
3355 //in some NP models it may not be the case.Unfortunately, bbH is not
3356 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3357 //SMEFT and add here the general expression.
3358 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3359 double xsSM_ggHbbH = 44.745;
3360 double xsSM_VBF = 3.49948;
3361 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3362 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3363 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3364 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3365 //AG: Most general expression including quadratic corrections.
3366 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3367 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3368 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3369 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3370 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3371
3372 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3373 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3374 double Br1 = dGammaR1-dGammaRTot1;
3375 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3376
3377 double mu;
3378
3379 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3380
3381 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3382
3383 return mu;
3384
3385 } else {
3386
3387
3388 //VM: Just in case someone wants to add directly the production*decay
3389 //(which is the observable we fit at the end). Furthermore, the Hbb
3390 //is not added in the original formula, fine for the SM (probably also
3391 //for the SMEFT) but not for all NP models.
3392 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3393 if(NPmuggHpVBFpbbH_Hbb==1.0){
3394 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3395 } else {
3396 return NPmuggHpVBFpbbH_Hbb;
3397 }
3398 }
3399}
3400
3401
3402
3403muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3404: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3405{
3406 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3407 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3408}
3409
3411{
3412 if ((this->getModel()).isModelLinearized()) {
3413 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3414 } else {
3415 return myNPbase->muVHcc(sqrt_s);
3416 }
3417}
3418
3419
3420muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3421: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3422{
3423 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3424 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3425}
3426
3428{
3429
3430 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3431
3432}
3433
3434muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3435: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3436{
3437 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3438 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3439}
3440
3442{
3443
3444 if ((this->getModel()).isModelLinearized()) {
3445 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3446 } else {
3447 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3448 }
3449
3450}
3451
3452
3453muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3454: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3455{
3456 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3457 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3458}
3459
3461{
3462
3463 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3464
3465}
3466
3467muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3468: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3469{
3470 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3471 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3472}
3473
3475{
3476
3477 if ((this->getModel()).isModelLinearized()) {
3478 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3479 } else {
3480 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3481 }
3482
3483}
3484
3485
3486muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3487: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3488{
3489 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3490 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3491}
3492
3494{
3495 return myNPbase->muppHmumu(sqrt_s);
3496}
3497
3498muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3499: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3500{
3501 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3502 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3503}
3504
3506{
3507 return myNPbase->muppHZga(sqrt_s);
3508}
3509
3510muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3511: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3512{
3513 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3514 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3515}
3516
3518{
3519 if ((this->getModel()).isModelLinearized()) {
3520 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3521 } else {
3523 }
3524}
3525
3526muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3527: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3528{
3529 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3530 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3531}
3532
3534{
3535 return (myNPbase->muttHZbbboost(sqrt_s));
3536}
3537
3538//AG:begin
3539ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3540: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3541{
3542 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3543 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3544}
3546{
3547 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3548 if ((this->getModel()).isModelLinearized()) {
3549 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3550 } else {
3551 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3552 }
3553}
3554
3555
3556ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3557: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3558{
3559 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3560 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3561}
3563{
3564 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3565 if ((this->getModel()).isModelLinearized()) {
3566 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3567 } else {
3568 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3569 }
3570}
3571
3572
3573ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3574: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3575{
3576 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3577 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3578}
3580{
3581 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3582 if ((this->getModel()).isModelLinearized()) {
3583 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3584 } else {
3585 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3586 }
3587}
3588
3589
3590ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3591: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3592{
3593 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3594 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3595}
3597{
3598 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3599 if ((this->getModel()).isModelLinearized()) {
3600 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3601 } else {
3602 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3603 }
3604}
3605
3606
3607VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3608: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3609{
3610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3611 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3612}
3614{
3615 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3616 if ((this->getModel()).isModelLinearized()) {
3617 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3618 } else {
3619 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3620 }
3621}
3622
3623
3624VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3625: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3626{
3627 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3628 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3629}
3631{
3632 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3633 if ((this->getModel()).isModelLinearized()) {
3634 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3635 } else {
3636 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3637 }
3638}
3639
3640
3641VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3642: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3643{
3644 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3645 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3646}
3648{
3649 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3650 if ((this->getModel()).isModelLinearized()) {
3651 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3652 } else {
3653 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3654 }
3655}
3656
3657
3658VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3659: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3660{
3661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3662 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3663}
3665{
3666 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3667 if ((this->getModel()).isModelLinearized()) {
3668 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3669 } else {
3670 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3671 }
3672}
3673
3674
3675WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3676: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3677{
3678 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3679 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3680}
3682{
3683 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3684 if ((this->getModel()).isModelLinearized()) {
3685 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3686 } else {
3687 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3688 }
3689}
3690
3691
3692WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3694{
3695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3696 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3697}
3699{
3700 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3701 if ((this->getModel()).isModelLinearized()) {
3702 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3703 } else {
3704 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3705 }
3706}
3707
3708
3709WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3710: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3711{
3712 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3713 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3714}
3716{
3717 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3718 if ((this->getModel()).isModelLinearized()) {
3719 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3720 } else {
3721 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3722 }
3723}
3724
3725
3726WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3727: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3728{
3729 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3730 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3731}
3733{
3734 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3735 if ((this->getModel()).isModelLinearized()) {
3736 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3737 } else {
3738 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3739 }
3740}
3741
3742
3743ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3744: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3745{
3746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3747 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3748}
3750{
3751 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3752 if ((this->getModel()).isModelLinearized()) {
3753 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3754 } else {
3755 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3756 }
3757}
3758
3759
3760ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3761: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3762{
3763 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3764 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3765}
3767{
3768 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3769 if ((this->getModel()).isModelLinearized()) {
3770 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3771 } else {
3772 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3773 }
3774}
3775
3776
3777ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3778: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3779{
3780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3781 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3782}
3784{
3785 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3786 if ((this->getModel()).isModelLinearized()) {
3787 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3788 } else {
3789 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3790 }
3791}
3792
3793
3794ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3795: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3796{
3797 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3798 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3799}
3801{
3802 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3803 if ((this->getModel()).isModelLinearized()) {
3804 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3805 } else {
3806 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3807 }
3808}
3809
3810
3811ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3812: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3813{
3814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3815 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3816}
3818{
3819 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3820 if ((this->getModel()).isModelLinearized()) {
3821 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3822 } else {
3823 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3824 }
3825}
3826
3827
3828ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3829: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3830{
3831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3832 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3833}
3835{
3836 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3837 if ((this->getModel()).isModelLinearized()) {
3838 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3839 } else {
3840 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3841 }
3842}
3843
3844
3845ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3846: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3847{
3848 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3849 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3850}
3852{
3853 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3854 if ((this->getModel()).isModelLinearized()) {
3855 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3856 } else {
3857 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3858 }
3859}
3860
3861
3862ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3863: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3864{
3865 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3866 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
3867}
3869{
3870 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3871 if ((this->getModel()).isModelLinearized()) {
3872 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3873 } else {
3874 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
3875 }
3876}
3877
3878//AG:end
3879
3880UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3881{
3882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3883 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
3884}
3885
3887{
3889}
3890
3891UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3892{
3893 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3894 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
3895}
3896
3898{
3900}
3901
3902UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3903{
3904 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3905 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
3906}
3907
3909{
3911}
3912
3913UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3914{
3915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3916 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
3917}
3918
3920{
3922}
3923
3925{
3926 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3927 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
3928}
3929
3931{
3932 return myNPbase->cgplusct();
3933}
3934
3936{
3937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3938 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
3939}
3940
3942{
3943 return myNPbase->cgaplusct();
3944}
3945
3947{
3948 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3949 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
3950}
3951
3953{
3954 return myNPbase->cgminuscga();
3955}
3956
3958{
3959 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3960 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
3961}
3962\
3963
3964
3966{
3967 return myNPbase->cVpluscb();
3968}
3969
3971{
3972 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3973 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
3974}
3975
3977{
3978 return myNPbase->cVplusctau();
3979}
3980
3982{
3983 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3984 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
3985}
3986
3988{
3989 return myNPbase->cbminuscc();
3990}
3991
3993{
3994 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3995 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
3996}
3997
3999{
4000 return myNPbase->cbminusctau();
4001}
4002
4004{
4005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4006 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4007}
4008
4010{
4011 return myNPbase->ccminusctau();
4012}
4013
4014
4015// Full signal strengths at e+ e- colliders
4016// ----------------------------------------
4017
4018mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i)
4019: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4020{
4021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4022 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4023}
4024
4026{
4027 if ((this->getModel()).isModelLinearized()) {
4028 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4029 } else {
4030 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHbbRatio());
4031 }
4032}
4033
4034mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i)
4035: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4036{
4037 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4038 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4039}
4040
4042{
4043 if ((this->getModel()).isModelLinearized()) {
4044 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4045 } else {
4046 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHccRatio());
4047 }
4048}
4049
4050mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i)
4051: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4052{
4053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4054 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4055}
4056
4058{
4059 if ((this->getModel()).isModelLinearized()) {
4060 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHssRatio()) - 1.0);
4061 } else {
4062 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHssRatio());
4063 }
4064}
4065
4066mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i)
4067: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4068{
4069 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4070 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4071}
4072
4074{
4075 if ((this->getModel()).isModelLinearized()) {
4076 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4077 } else {
4078 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHggRatio());
4079 }
4080}
4081
4082mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i)
4083: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4084{
4085 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4086 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4087}
4088
4090{
4091 if ((this->getModel()).isModelLinearized()) {
4092 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4093 } else {
4094 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHWWRatio());
4095 }
4096}
4097
4098mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4099: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4100{
4101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4102 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4103}
4104
4106{
4107 if ((this->getModel()).isModelLinearized()) {
4108 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4109 } else {
4111 }
4112}
4113
4114mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
4115: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4116{
4117 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4118 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4119}
4120
4122{
4123 if ((this->getModel()).isModelLinearized()) {
4124 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4125 } else {
4126 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHZZRatio());
4127 }
4128}
4129
4130mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i)
4131: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4132{
4133 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4134 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4135}
4136
4138{
4139 if ((this->getModel()).isModelLinearized()) {
4140 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4141 } else {
4142 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHZgaRatio());
4143 }
4144}
4145
4146mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4147: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4148{
4149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4150 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4151}
4152
4154{
4155 if ((this->getModel()).isModelLinearized()) {
4156 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4157 } else {
4158 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHgagaRatio());
4159 }
4160}
4161
4162mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
4163: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4164{
4165 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4166 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4167}
4168
4170{
4171 if ((this->getModel()).isModelLinearized()) {
4172 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4173 } else {
4174 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHmumuRatio());
4175 }
4176}
4177
4178mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
4179: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4180{
4181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4182 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4183}
4184
4186{
4187
4188 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->Br_H_inv());
4189
4190}
4191
4192mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i)
4193: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4194{
4195 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4196 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4197}
4198
4200{
4201
4202 if ((this->getModel()).isModelLinearized()) {
4203 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4204 } else {
4206 }
4207
4208}
4209
4210mueeZHbbPol::mueeZHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4211: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4212{
4213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4214 throw std::runtime_error("mueeZHbbPol called with a class whose parent is not NPbase");
4215}
4216
4218{
4219 if ((this->getModel()).isModelLinearized()) {
4220 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4221 } else {
4223 }
4224}
4225
4226mueeZHccPol::mueeZHccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4227: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4228{
4229 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4230 throw std::runtime_error("mueeZHccPol called with a class whose parent is not NPbase");
4231}
4232
4234{
4235 if ((this->getModel()).isModelLinearized()) {
4236 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4237 } else {
4239 }
4240}
4241
4242mueeZHssPol::mueeZHssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4243: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4244{
4245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4246 throw std::runtime_error("mueeZHssPol called with a class whose parent is not NPbase");
4247}
4248
4250{
4251 if ((this->getModel()).isModelLinearized()) {
4252 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4253 } else {
4255 }
4256}
4257
4258mueeZHggPol::mueeZHggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4259: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4260{
4261 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4262 throw std::runtime_error("mueeZHggPol called with a class whose parent is not NPbase");
4263}
4264
4266{
4267 if ((this->getModel()).isModelLinearized()) {
4268 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4269 } else {
4271 }
4272}
4273
4274mueeZHWWPol::mueeZHWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4275: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4276{
4277 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4278 throw std::runtime_error("mueeZHWWPol called with a class whose parent is not NPbase");
4279}
4280
4282{
4283 if ((this->getModel()).isModelLinearized()) {
4284 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4285 } else {
4287 }
4288}
4289
4290mueeZHtautauPol::mueeZHtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4291: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4292{
4293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4294 throw std::runtime_error("mueeZHtautauPol called with a class whose parent is not NPbase");
4295}
4296
4298{
4299 if ((this->getModel()).isModelLinearized()) {
4300 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4301 } else {
4303 }
4304}
4305
4306mueeZHZZPol::mueeZHZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4307: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4308{
4309 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4310 throw std::runtime_error("mueeZHZZPol called with a class whose parent is not NPbase");
4311}
4312
4314{
4315 if ((this->getModel()).isModelLinearized()) {
4316 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4317 } else {
4319 }
4320}
4321
4322mueeZHZgaPol::mueeZHZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4323: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4324{
4325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4326 throw std::runtime_error("mueeZHZgaPol called with a class whose parent is not NPbase");
4327}
4328
4330{
4331 if ((this->getModel()).isModelLinearized()) {
4332 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4333 } else {
4335 }
4336}
4337
4338mueeZHgagaPol::mueeZHgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4339: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4340{
4341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4342 throw std::runtime_error("mueeZHgagaPol called with a class whose parent is not NPbase");
4343}
4344
4346{
4347 if ((this->getModel()).isModelLinearized()) {
4348 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4349 } else {
4351 }
4352}
4353
4354mueeZHmumuPol::mueeZHmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4355: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4356{
4357 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4358 throw std::runtime_error("mueeZHmumuPol called with a class whose parent is not NPbase");
4359}
4360
4362{
4363 if ((this->getModel()).isModelLinearized()) {
4364 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4365 } else {
4367 }
4368}
4369
4370mueeZHBRinvPol::mueeZHBRinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4371: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4372{
4373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4374 throw std::runtime_error("mueeZHBRinvPol called with a class whose parent is not NPbase");
4375}
4376
4378{
4380
4381}
4382
4383mueeZHinvPol::mueeZHinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4385{
4386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4387 throw std::runtime_error("mueeZHinvPol called with a class whose parent is not NPbase");
4388}
4389
4391{
4392
4393 if ((this->getModel()).isModelLinearized()) {
4394 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4395 } else {
4397 }
4398
4399}
4400
4401mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4402: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4403{
4404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4405 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4406
4407}
4408
4410{
4411 if ((this->getModel()).isModelLinearized()) {
4412 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4413 } else {
4414 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4415 }
4416}
4417
4418mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4419: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4420{
4421 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4422 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4423
4424}
4425
4427{
4428 if ((this->getModel()).isModelLinearized()) {
4429 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4430 } else {
4432 }
4433}
4434
4435mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4436: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4437{
4438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4439 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4440
4441}
4442
4444{
4445 if ((this->getModel()).isModelLinearized()) {
4446 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4447 } else {
4448 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4449 }
4450}
4451
4452mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4453: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4454{
4455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4456 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4457
4458}
4459
4461{
4462 if ((this->getModel()).isModelLinearized()) {
4463 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4464 } else {
4465 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4466 }
4467}
4468
4469mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4470: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4471{
4472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4473 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4474
4475}
4476
4478{
4479 if ((this->getModel()).isModelLinearized()) {
4480 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4481 } else {
4482 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4483 }
4484}
4485
4486mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4487: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4488{
4489 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4490 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4491
4492}
4493
4495{
4496 if ((this->getModel()).isModelLinearized()) {
4497 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4498 } else {
4500 }
4501}
4502
4503mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4504: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4505{
4506 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4507 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4508
4509}
4510
4512{
4513 if ((this->getModel()).isModelLinearized()) {
4514 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4515 } else {
4516 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4517 }
4518}
4519
4520mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4521: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4522{
4523 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4524 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4525
4526}
4527
4529{
4530 if ((this->getModel()).isModelLinearized()) {
4531 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4532 } else {
4533 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4534 }
4535}
4536
4537mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4538: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4539{
4540 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4541 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4542
4543}
4544
4546{
4547 if ((this->getModel()).isModelLinearized()) {
4548 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4549 } else {
4551 }
4552}
4553
4554mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4555: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4556{
4557 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4558 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4559
4560}
4561
4563{
4564 if ((this->getModel()).isModelLinearized()) {
4565 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4566 } else {
4568 }
4569}
4570
4571mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4572: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4573{
4574 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4575 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4576
4577}
4578
4580{
4581 if ((this->getModel()).isModelLinearized()) {
4582 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4583 } else {
4584 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4585 }
4586}
4587
4588mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4589: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4590{
4591 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4592 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4593
4594}
4595
4597{
4598 if ((this->getModel()).isModelLinearized()) {
4599 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4600 } else {
4602 }
4603}
4604
4605mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4606: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4607{
4608 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4609 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4610
4611}
4612
4614{
4615 if ((this->getModel()).isModelLinearized()) {
4616 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4617 } else {
4618 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4619 }
4620}
4621
4622mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4623: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4624{
4625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4626 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4627
4628}
4629
4631{
4632 if ((this->getModel()).isModelLinearized()) {
4633 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4634 } else {
4636 }
4637}
4638
4639mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4640: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4641{
4642 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4643 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4644
4645}
4646
4648{
4649 if ((this->getModel()).isModelLinearized()) {
4650 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4651 } else {
4652 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4653 }
4654}
4655
4656mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4657: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4658{
4659 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4660 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4661
4662}
4663
4665{
4666 if ((this->getModel()).isModelLinearized()) {
4667 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4668 } else {
4670 }
4671}
4672
4673mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4674: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4675{
4676 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4677 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4678
4679}
4680
4682{
4683 if ((this->getModel()).isModelLinearized()) {
4684 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4685 } else {
4686 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4687 }
4688}
4689
4690mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4691: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4692{
4693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4694 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4695
4696}
4697
4699{
4700 if ((this->getModel()).isModelLinearized()) {
4701 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4702 } else {
4704 }
4705}
4706
4707mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4708: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4709{
4710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4711 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4712
4713}
4714
4716{
4717 if ((this->getModel()).isModelLinearized()) {
4718 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4719 } else {
4721 }
4722}
4723
4724mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4725: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4726{
4727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4728 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4729
4730}
4731
4733{
4734 if ((this->getModel()).isModelLinearized()) {
4735 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4736 } else {
4738 }
4739}
4740
4741mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4742: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4743{
4744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4745 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4746
4747}
4748
4750{
4751 if ((this->getModel()).isModelLinearized()) {
4752 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4753 } else {
4754 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4755 }
4756}
4757
4758mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4759: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4760{
4761 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4762 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4763
4764}
4765
4767{
4768 if ((this->getModel()).isModelLinearized()) {
4769 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4770 } else {
4772 }
4773}
4774
4775mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4777{
4778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4779 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4780
4781}
4782
4784{
4785 if ((this->getModel()).isModelLinearized()) {
4786 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4787 } else {
4788 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4789 }
4790}
4791
4792mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4793: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4794{
4795 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4796 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4797
4798}
4799
4801{
4802 if ((this->getModel()).isModelLinearized()) {
4803 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4804 } else {
4806 }
4807}
4808
4809mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4810: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4811{
4812 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4813 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4814
4815}
4816
4818{
4819 if ((this->getModel()).isModelLinearized()) {
4820 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4821 } else {
4823 }
4824}
4825
4826mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4827: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4828{
4829 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4830 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4831
4832}
4833
4835{
4836 if ((this->getModel()).isModelLinearized()) {
4837 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4838 } else {
4840 }
4841}
4842
4843mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4845{
4846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4847 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4848
4849}
4850
4852{
4853 if ((this->getModel()).isModelLinearized()) {
4854 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4855 } else {
4857 }
4858}
4859
4860mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4861: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4862{
4863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4864 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4865
4866}
4867
4869{
4870 if ((this->getModel()).isModelLinearized()) {
4871 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4872 } else {
4874 }
4875}
4876
4877mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4878: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4879{
4880 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4881 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4882}
4883
4885{
4886 if ((this->getModel()).isModelLinearized()) {
4887 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4888 } else {
4889 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4890 }
4891}
4892
4893mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4894: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4895{
4896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4897 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4898}
4899
4901{
4902 if ((this->getModel()).isModelLinearized()) {
4903 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4904 } else {
4906 }
4907}
4908
4909mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4910: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4911{
4912 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4913 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4914}
4915
4917{
4918 if ((this->getModel()).isModelLinearized()) {
4919 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4920 } else {
4921 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4922 }
4923}
4924
4925mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4926: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4927{
4928 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4929 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4930}
4931
4933{
4934 if ((this->getModel()).isModelLinearized()) {
4935 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4936 } else {
4938 }
4939}
4940
4941
4942// Production signal strengths at mu+ mu- colliders
4943// ------------------------------------------------
4944
4945mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4946: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4947{
4948 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4949 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4950}
4951
4953{
4954 return myNPbase->mummZH(sqrt_s);
4955}
4956
4957
4958mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4959: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4960{
4961 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4962 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4963}
4964
4966{
4967 return myNPbase->mummHvv(sqrt_s);
4968}
4969
4970
4971mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4972: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4973{
4974 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4975 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4976}
4977
4979{
4980 return myNPbase->mummttH(sqrt_s);
4981}
4982
4983
4984// Full signal strengths at mu+ mu- colliders
4985// -------------------------------------------
4986
4987
4988mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4989: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4990{
4991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4992 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4993}
4994
4996{
4997 if ((this->getModel()).isModelLinearized()) {
4998 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4999 } else {
5000 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
5001 }
5002}
5003
5004mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
5005: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5006{
5007 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5008 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5009}
5010
5012{
5013 if ((this->getModel()).isModelLinearized()) {
5014 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5015 } else {
5016 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
5017 }
5018}
5019
5020mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
5021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5022{
5023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5024 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
5025}
5026
5028{
5029 if ((this->getModel()).isModelLinearized()) {
5030 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5031 } else {
5032 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5033 }
5034}
5035
5036mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5037: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5038{
5039 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5040 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5041}
5042
5044{
5045 if ((this->getModel()).isModelLinearized()) {
5046 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5047 } else {
5048 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5049 }
5050}
5051
5052mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5053: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5054{
5055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5056 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5057}
5058
5060{
5061 if ((this->getModel()).isModelLinearized()) {
5062 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5063 } else {
5065 }
5066}
5067
5068mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5069: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5070{
5071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5072 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5073}
5074
5076{
5077 if ((this->getModel()).isModelLinearized()) {
5078 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5079 } else {
5080 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5081 }
5082}
5083
5084mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5085: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5086{
5087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5088 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5089}
5090
5092{
5093 if ((this->getModel()).isModelLinearized()) {
5094 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5095 } else {
5096 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5097 }
5098}
5099
5100mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5101: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5102{
5103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5104 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5105}
5106
5108{
5109 if ((this->getModel()).isModelLinearized()) {
5110 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5111 } else {
5112 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5113 }
5114}
5115
5116mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5118{
5119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5120 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5121}
5122
5124{
5125 if ((this->getModel()).isModelLinearized()) {
5126 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5127 } else {
5128 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5129 }
5130}
5131
5132
5133
5134mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5136{
5137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5138 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5139}
5140
5142{
5143 if ((this->getModel()).isModelLinearized()) {
5144 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5145 } else {
5146 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5147 }
5148}
5149
5150mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5152{
5153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5154 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5155}
5156
5158{
5159 if ((this->getModel()).isModelLinearized()) {
5160 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5161 } else {
5162 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5163 }
5164}
5165
5166mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5167: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5168{
5169 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5170 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5171}
5172
5174{
5175 if ((this->getModel()).isModelLinearized()) {
5176 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5177 } else {
5178 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5179 }
5180}
5181
5182mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5184{
5185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5186 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5187}
5188
5190{
5191 if ((this->getModel()).isModelLinearized()) {
5192 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5193 } else {
5194 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5195 }
5196}
5197
5198mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5199: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5200{
5201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5202 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5203}
5204
5206{
5207 if ((this->getModel()).isModelLinearized()) {
5208 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5209 } else {
5211 }
5212}
5213
5214mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5215: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5216{
5217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5218 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5219}
5220
5222{
5223 if ((this->getModel()).isModelLinearized()) {
5224 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5225 } else {
5226 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5227 }
5228}
5229
5230mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5231: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5232{
5233 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5234 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5235}
5236
5238{
5239 if ((this->getModel()).isModelLinearized()) {
5240 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5241 } else {
5242 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5243 }
5244}
5245
5246mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5247: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5248{
5249 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5250 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5251}
5252
5254{
5255 if ((this->getModel()).isModelLinearized()) {
5256 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5257 } else {
5258 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5259 }
5260}
5261
5262mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5263: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5264{
5265 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5266 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5267}
5268
5270{
5271 if ((this->getModel()).isModelLinearized()) {
5272 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5273 } else {
5274 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5275 }
5276}
5277
5278
5279
5280mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5281: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5282{
5283 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5284 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5285}
5286
5288{
5289 if ((this->getModel()).isModelLinearized()) {
5290 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5291 } else {
5292 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5293 }
5294}
5295
5296mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5298{
5299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5300 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5301}
5302
5304{
5305 if ((this->getModel()).isModelLinearized()) {
5306 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5307 } else {
5308 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5309 }
5310}
5311
5312mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5313: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5314{
5315 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5316 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5317}
5318
5320{
5321 if ((this->getModel()).isModelLinearized()) {
5322 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5323 } else {
5324 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5325 }
5326}
5327
5328mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5329: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5330{
5331 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5332 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5333}
5334
5336{
5337 if ((this->getModel()).isModelLinearized()) {
5338 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5339 } else {
5340 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5341 }
5342}
5343
5344mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5346{
5347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5348 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5349}
5350
5352{
5353 if ((this->getModel()).isModelLinearized()) {
5354 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5355 } else {
5357 }
5358}
5359
5360mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5361: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5362{
5363 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5364 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5365}
5366
5368{
5369 if ((this->getModel()).isModelLinearized()) {
5370 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5371 } else {
5372 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5373 }
5374}
5375
5376mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5377: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5378{
5379 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5380 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5381}
5382
5384{
5385 if ((this->getModel()).isModelLinearized()) {
5386 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5387 } else {
5388 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5389 }
5390}
5391
5392mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5393: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5394{
5395 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5396 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5397}
5398
5400{
5401 if ((this->getModel()).isModelLinearized()) {
5402 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5403 } else {
5405 }
5406}
5407
5408mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5409: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5410{
5411 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5412 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5413}
5414
5416{
5417 if ((this->getModel()).isModelLinearized()) {
5418 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5419 } else {
5421 }
5422}
5423
5424
5425
5426mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5427: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5428{
5429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5430 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5431}
5432
5434{
5435 if ((this->getModel()).isModelLinearized()) {
5436 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5437 } else {
5438 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5439 }
5440}
5441
5442mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5443: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5444{
5445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5446 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5447}
5448
5450{
5451 if ((this->getModel()).isModelLinearized()) {
5452 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5453 } else {
5454 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5455 }
5456}
5457
5458mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5459: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5460{
5461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5462 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5463}
5464
5466{
5467 if ((this->getModel()).isModelLinearized()) {
5468 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5469 } else {
5470 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5471 }
5472}
5473
5474mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5475: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5476{
5477 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5478 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5479}
5480
5482{
5483 if ((this->getModel()).isModelLinearized()) {
5484 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5485 } else {
5486 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5487 }
5488}
5489
5490mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5491: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5492{
5493 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5494 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5495}
5496
5498{
5499 if ((this->getModel()).isModelLinearized()) {
5500 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5501 } else {
5503 }
5504}
5505
5506mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5507: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5508{
5509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5510 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5511}
5512
5514{
5515 if ((this->getModel()).isModelLinearized()) {
5516 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5517 } else {
5518 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5519 }
5520}
5521
5522mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5523: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5524{
5525 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5526 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5527}
5528
5530{
5531 if ((this->getModel()).isModelLinearized()) {
5532 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5533 } else {
5534 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5535 }
5536}
5537
5538mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5539: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5540{
5541 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5542 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5543}
5544
5546{
5547 if ((this->getModel()).isModelLinearized()) {
5548 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5549 } else {
5551 }
5552}
5553
5554mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5555: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5556{
5557 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5558 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5559}
5560
5562{
5563 if ((this->getModel()).isModelLinearized()) {
5564 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5565 } else {
5567 }
5568}
5569
5570
5571mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5572: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5573{
5574 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5575 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5576}
5577
5579{
5580 if ((this->getModel()).isModelLinearized()) {
5581 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5582 } else {
5583 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5584 }
5585}
5586
5587mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5588: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5589{
5590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5591 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5592}
5593
5595{
5596 if ((this->getModel()).isModelLinearized()) {
5597 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5598 } else {
5599 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5600 }
5601}
5602
5603mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5604: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5605{
5606 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5607 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5608}
5609
5611{
5612 if ((this->getModel()).isModelLinearized()) {
5613 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5614 } else {
5615 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5616 }
5617}
5618
5619mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5620: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5621{
5622 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5623 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5624}
5625
5627{
5628 if ((this->getModel()).isModelLinearized()) {
5629 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5630 } else {
5631 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5632 }
5633}
5634
5635mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5637{
5638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5639 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5640}
5641
5643{
5644 if ((this->getModel()).isModelLinearized()) {
5645 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5646 } else {
5648 }
5649}
5650
5651mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5652: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5653{
5654 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5655 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5656}
5657
5659{
5660 if ((this->getModel()).isModelLinearized()) {
5661 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5662 } else {
5663 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5664 }
5665}
5666
5667mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5668: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5669{
5670 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5671 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5672}
5673
5675{
5676 if ((this->getModel()).isModelLinearized()) {
5677 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5678 } else {
5679 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5680 }
5681}
5682
5683mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5684: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5685{
5686 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5687 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5688}
5689
5691{
5692 if ((this->getModel()).isModelLinearized()) {
5693 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5694 } else {
5696 }
5697}
5698
5699mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5700: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5701{
5702 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5703 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5704}
5705
5707{
5708 if ((this->getModel()).isModelLinearized()) {
5709 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5710 } else {
5712 }
5713}
5714
5715
5716// The same in the narrow width approximation
5717
5718mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5719: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5720{
5721 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5722 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5723}
5724
5726{
5727 if ((this->getModel()).isModelLinearized()) {
5728 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5729 } else {
5730 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5731 }
5732}
5733
5734mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5735: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5736{
5737 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5738 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5739}
5740
5742{
5743 if ((this->getModel()).isModelLinearized()) {
5744 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5745 } else {
5746 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5747 }
5748}
5749
5750mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5752{
5753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5754 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5755}
5756
5758{
5759 if ((this->getModel()).isModelLinearized()) {
5760 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5761 } else {
5762 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5763 }
5764}
5765
5766mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5767: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5768{
5769 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5770 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5771}
5772
5774{
5775 if ((this->getModel()).isModelLinearized()) {
5776 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5777 } else {
5778 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5779 }
5780}
5781
5782mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5783: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5784{
5785 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5786 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5787}
5788
5790{
5791 if ((this->getModel()).isModelLinearized()) {
5792 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5793 } else {
5795 }
5796}
5797
5798mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5799: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5800{
5801 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5802 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5803}
5804
5806{
5807 if ((this->getModel()).isModelLinearized()) {
5808 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5809 } else {
5810 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5811 }
5812}
5813
5814mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5815: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5816{
5817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5818 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5819}
5820
5822{
5823 if ((this->getModel()).isModelLinearized()) {
5824 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5825 } else {
5827 }
5828}
5829
5830mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5831: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5832{
5833 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5834 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5835}
5836
5838{
5839 if ((this->getModel()).isModelLinearized()) {
5840 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5841 } else {
5843 }
5844}
5845
5846mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5847: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5848{
5849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5850 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5851}
5852
5854{
5855 if ((this->getModel()).isModelLinearized()) {
5856 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5857 } else {
5859 }
5860}
5861
5862// Full signal strengths at ep colliders
5863// -------------------------------------
5864
5865muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5866: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5867{
5868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5869 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5870
5871}
5872
5874{
5875 if ((this->getModel()).isModelLinearized()) {
5876 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5877 } else {
5878 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5879 }
5880}
5881
5882muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5884{
5885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5886 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5887
5888}
5889
5891{
5892 if ((this->getModel()).isModelLinearized()) {
5893 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5894 } else {
5895 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5896 }
5897}
5898
5899muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5900: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5901{
5902 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5903 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5904
5905}
5906
5908{
5909 if ((this->getModel()).isModelLinearized()) {
5910 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5911 } else {
5912 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5913 }
5914}
5915
5916muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5917: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5918{
5919 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5920 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5921
5922}
5923
5925{
5926 if ((this->getModel()).isModelLinearized()) {
5927 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5928 } else {
5930 }
5931}
5932
5933muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5934: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5935{
5936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5937 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5938
5939}
5940
5942{
5943 if ((this->getModel()).isModelLinearized()) {
5944 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5945 } else {
5946 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5947 }
5948}
5949
5950muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5951: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5952{
5953 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5954 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5955
5956}
5957
5959{
5960 if ((this->getModel()).isModelLinearized()) {
5961 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5962 } else {
5964 }
5965}
5966
5967muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5968: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5969{
5970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5971 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5972
5973}
5974
5976{
5977 if ((this->getModel()).isModelLinearized()) {
5978 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5979 } else {
5981 }
5982}
5983
5984muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5986{
5987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5988 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5989
5990}
5991
5993{
5994 if ((this->getModel()).isModelLinearized()) {
5995 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5996 } else {
5997 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5998 }
5999}
6000
6001muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
6002: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6003{
6004 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6005 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
6006
6007}
6008
6010{
6011 if ((this->getModel()).isModelLinearized()) {
6012 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6013 } else {
6014 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
6015 }
6016}
6017
6018muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6019: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6020{
6021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6022 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
6023
6024}
6025
6027{
6028 if ((this->getModel()).isModelLinearized()) {
6029 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6030 } else {
6031 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
6032 }
6033}
6034
6035muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6036: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6037{
6038 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6039 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6040
6041}
6042
6044{
6045 if ((this->getModel()).isModelLinearized()) {
6046 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6047 } else {
6049 }
6050}
6051
6052muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6053: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6054{
6055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6056 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6057
6058}
6059
6061{
6062 if ((this->getModel()).isModelLinearized()) {
6063 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6064 } else {
6065 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6066 }
6067}
6068
6069muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6070: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6071{
6072 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6073 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6074
6075}
6076
6078{
6079 if ((this->getModel()).isModelLinearized()) {
6080 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6081 } else {
6083 }
6084}
6085
6086muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6088{
6089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6090 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6091
6092}
6093
6095{
6096 if ((this->getModel()).isModelLinearized()) {
6097 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6098 } else {
6100 }
6101}
6102
6103
6104// -----------------------------------------------------------------------------
6105// STXS bins
6106// -----------------------------------------------------------------------------
6107
6108// -----------------------------------------------------------------------------
6109// Stage 0
6110// -----------------------------------------------------------------------------
6111
6112STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6113: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6114{
6115 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6116 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6117
6118}
6119
6121{
6122 return myNPbase->STXS0_qqH(sqrt_s);
6123}
6124
6125
6126// -----------------------------------------------------------------------------
6127// Stage 1
6128// -----------------------------------------------------------------------------
6129
6131: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6132{
6133 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6134 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6135
6136}
6137
6139{
6140 if ((this->getModel()).isModelLinearized()) {
6141 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6142 } else {
6144 }
6145}
6146
6147
6149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6150{
6151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6152 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6153
6154}
6155
6157{
6158 if ((this->getModel()).isModelLinearized()) {
6159 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6160 } else {
6162 }
6163}
6164
6165
6166STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6167: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6168{
6169 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6170 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6171
6172}
6173
6175{
6176 if ((this->getModel()).isModelLinearized()) {
6177 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6178 } else {
6180 }
6181}
6182
6184: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6185{
6186 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6187 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6188
6189}
6190
6192{
6193 if ((this->getModel()).isModelLinearized()) {
6194 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6195 } else {
6197 }
6198}
6199
6201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6202{
6203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6204 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6205
6206}
6207
6209{
6210 if ((this->getModel()).isModelLinearized()) {
6211 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6212 } else {
6214 }
6215}
6216
6218: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6219{
6220 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6221 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6222
6223}
6224
6226{
6227 if ((this->getModel()).isModelLinearized()) {
6228 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6229 } else {
6231 }
6232}
6233
6235: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6236{
6237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6238 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6239
6240}
6241
6243{
6244 if ((this->getModel()).isModelLinearized()) {
6245 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6246 } else {
6248 }
6249}
6250
6252: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6253{
6254 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6255 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6256
6257}
6258
6260{
6261 if ((this->getModel()).isModelLinearized()) {
6262 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6263 } else {
6265 }
6266}
6267
6268
6270: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6271{
6272 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6273 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6274
6275}
6276
6278{
6279 if ((this->getModel()).isModelLinearized()) {
6280 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6281 } else {
6283 }
6284}
6285
6286
6288: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6289{
6290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6291 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6292
6293}
6294
6296{
6297 if ((this->getModel()).isModelLinearized()) {
6298 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6299 } else {
6301 }
6302}
6303
6304
6306: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6307{
6308 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6309 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6310
6311}
6312
6314{
6315 if ((this->getModel()).isModelLinearized()) {
6316 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6317 } else {
6319 }
6320}
6321
6322
6324: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6325{
6326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6327 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6328
6329}
6330
6332{
6333 if ((this->getModel()).isModelLinearized()) {
6334 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6335 } else {
6337 }
6338}
6339
6340
6342: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6343{
6344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6345 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6346
6347}
6348
6350{
6351 if ((this->getModel()).isModelLinearized()) {
6352 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6353 } else {
6355 }
6356}
6357
6358
6360: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6361{
6362 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6363 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6364
6365}
6366
6368{
6369 if ((this->getModel()).isModelLinearized()) {
6370 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6371 } else {
6373 }
6374}
6375
6376
6377
6379: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6380{
6381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6382 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6383
6384}
6385
6387{
6388 if ((this->getModel()).isModelLinearized()) {
6389 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6390 } else {
6392 }
6393}
6394
6395
6396
6398: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6399{
6400 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6401 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6402
6403}
6404
6406{
6407 if ((this->getModel()).isModelLinearized()) {
6408 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6409 } else {
6411 }
6412}
6413
6414
6415
6417: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6418{
6419 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6420 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6421
6422}
6423
6425{
6426 if ((this->getModel()).isModelLinearized()) {
6427 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6428 } else {
6430 }
6431}
6432
6433
6434STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6435: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6436{
6437 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6438 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6439
6440}
6441
6443{
6444 if ((this->getModel()).isModelLinearized()) {
6445 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6446 } else {
6448 }
6449}
6450
6451
6453: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6454{
6455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6456 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6457
6458}
6459
6461{
6462 if ((this->getModel()).isModelLinearized()) {
6463 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6464 } else {
6466 }
6467}
6468
6470: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6471{
6472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6473 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6474
6475}
6476
6478{
6479 if ((this->getModel()).isModelLinearized()) {
6480 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6481 } else {
6483 }
6484}
6485
6486
6488: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6489{
6490 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6491 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6492
6493}
6494
6496{
6497 if ((this->getModel()).isModelLinearized()) {
6498 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6499 } else {
6501 }
6502}
6503
6504
6505
6507: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6508{
6509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6510 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6511
6512}
6513
6515{
6516 if ((this->getModel()).isModelLinearized()) {
6518 } else {
6520 }
6521}
6522
6523
6524
6526: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6527{
6528 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6529 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6530
6531}
6532
6534{
6535 if ((this->getModel()).isModelLinearized()) {
6537 } else {
6539 }
6540}
6541
6542
6544: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6545{
6546 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6547 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6548
6549}
6550
6552{
6553 if ((this->getModel()).isModelLinearized()) {
6554 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6555 } else {
6557 }
6558}
6559
6561: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6562{
6563 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6564 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6565
6566}
6567
6569{
6570 if ((this->getModel()).isModelLinearized()) {
6571 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6572 } else {
6574 }
6575}
6576
6578: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6579{
6580 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6581 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6582
6583}
6584
6586{
6587 if ((this->getModel()).isModelLinearized()) {
6588 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6589 } else {
6591 }
6592}
6593
6594
6596: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6597{
6598 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6599 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6600
6601}
6602
6604{
6605 if ((this->getModel()).isModelLinearized()) {
6607 } else {
6609 }
6610}
6611
6612
6614: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6615{
6616 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6617 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6618
6619}
6620
6622{
6623 if ((this->getModel()).isModelLinearized()) {
6625 } else {
6627 }
6628}
6629
6630
6632: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6633{
6634 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6635 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6636
6637}
6638
6640{
6641 if ((this->getModel()).isModelLinearized()) {
6642 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6643 } else {
6645 }
6646}
6647
6648STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6650{
6651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6652 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6653
6654}
6655
6657{
6658 if ((this->getModel()).isModelLinearized()) {
6659 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6660 } else {
6662 }
6663}
6664
6665
6667: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6668{
6669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6670 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6671
6672}
6673
6675{
6676 if ((this->getModel()).isModelLinearized()) {
6677 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6678 } else {
6680 }
6681}
6682
6683
6685: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6686{
6687 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6688 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6689
6690}
6691
6693{
6694 if ((this->getModel()).isModelLinearized()) {
6695 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6696 } else {
6698 }
6699}
6700
6701
6702
6704: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6705{
6706 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6707 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6708
6709}
6710
6712{
6713 if ((this->getModel()).isModelLinearized()) {
6715 } else {
6717 }
6718}
6719
6720
6721
6723: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6724{
6725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6726 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6727
6728}
6729
6731{
6732 if ((this->getModel()).isModelLinearized()) {
6734 } else {
6736 }
6737}
6738
6739
6741: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6742{
6743 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6744 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6745
6746}
6747
6749{
6750 if ((this->getModel()).isModelLinearized()) {
6751 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6752 } else {
6754 }
6755}
6756
6758: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6759{
6760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6761 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6762
6763}
6764
6766{
6767 if ((this->getModel()).isModelLinearized()) {
6768 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6769 } else {
6771 }
6772}
6773
6775: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6776{
6777 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6778 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6779
6780}
6781
6783{
6784 if ((this->getModel()).isModelLinearized()) {
6785 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6786 } else {
6788 }
6789}
6790
6791
6793: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6794{
6795 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6796 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6797
6798}
6799
6801{
6802 if ((this->getModel()).isModelLinearized()) {
6804 } else {
6806 }
6807}
6808
6809
6811: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6812{
6813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6814 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6815
6816}
6817
6819{
6820 if ((this->getModel()).isModelLinearized()) {
6822 } else {
6824 }
6825}
6826
6827
6829: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6830{
6831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6832 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6833
6834}
6835
6837{
6838 if ((this->getModel()).isModelLinearized()) {
6839 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6840 } else {
6842 }
6843}
6844
6845
6847: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6848{
6849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6850 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6851
6852}
6853
6855{
6856 if ((this->getModel()).isModelLinearized()) {
6858 } else {
6860 }
6861}
6862
6863
6865: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6866{
6867 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6868 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6869
6870}
6871
6873{
6874 if ((this->getModel()).isModelLinearized()) {
6875 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6876 } else {
6878 }
6879}
6880
6881
6883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6884{
6885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6886 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6887
6888}
6889
6891{
6892 if ((this->getModel()).isModelLinearized()) {
6893 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6894 } else {
6896 }
6897}
6898
6899
6901: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6902{
6903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6904 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6905
6906}
6907
6909{
6910 if ((this->getModel()).isModelLinearized()) {
6911 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6912 } else {
6914 }
6915}
6916
6917
6919: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6920{
6921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6922 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6923
6924}
6925
6927{
6928 if ((this->getModel()).isModelLinearized()) {
6929 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6930 } else {
6932 }
6933}
6934
6935
6937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6938{
6939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6940 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6941
6942}
6943
6945{
6946 if ((this->getModel()).isModelLinearized()) {
6948 } else {
6950 }
6951}
6952
6953
6955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6956{
6957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6958 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6959
6960}
6961
6963{
6964 if ((this->getModel()).isModelLinearized()) {
6965 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6966 } else {
6968 }
6969}
6970
6971
6973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6974{
6975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6976 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6977
6978}
6979
6981{
6982 if ((this->getModel()).isModelLinearized()) {
6983 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6984 } else {
6986 }
6987}
6988
6989
6991: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6992{
6993 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6994 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6995
6996}
6997
6999{
7000 if ((this->getModel()).isModelLinearized()) {
7001 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7002 } else {
7004 }
7005}
7006
7007
7009: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7010{
7011 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7012 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7013
7014}
7015
7017{
7018 if ((this->getModel()).isModelLinearized()) {
7019 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7020 } else {
7022 }
7023}
7024
7025
7026
7027// -----------------------------------------------------------------------------
7028// Stage 1.2
7029// -----------------------------------------------------------------------------
7030
7031STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7032: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7033{
7034 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7035 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7036
7037}
7038
7040{
7041 double BrHXXRatio = 1.0;
7042 if (fstate == 1){
7043 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7044 } else if (fstate == 2){
7045 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7046 } else if (fstate == 3){
7047 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7048 } else if (fstate == 4){
7049 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7050 } else {
7051 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7052 }
7053
7054 if ((this->getModel()).isModelLinearized()) {
7055 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7056 } else {
7057 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7058 }
7059}
7060
7061// -----------------------------------------------------------------------------
7062
7063STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7064: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7065{
7066 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7067 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7068
7069}
7070
7072{
7073 double BrHXXRatio = 1.0;
7074 if (fstate == 1){
7075 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7076 } else if (fstate == 2){
7077 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7078 } else if (fstate == 3){
7079 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7080 } else if (fstate == 4){
7081 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7082 } else {
7083 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7084 }
7085
7086 if ((this->getModel()).isModelLinearized()) {
7087 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7088 } else {
7089 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7090 }
7091}
7092
7093// -----------------------------------------------------------------------------
7094
7095STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7096: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7097{
7098 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7099 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7100
7101}
7102
7104{
7105 double BrHXXRatio = 1.0;
7106 if (fstate == 1){
7107 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7108 } else if (fstate == 2){
7109 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7110 } else if (fstate == 3){
7111 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7112 } else if (fstate == 4){
7113 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7114 } else {
7115 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7116 }
7117
7118 if ((this->getModel()).isModelLinearized()) {
7119 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7120 } else {
7121 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7122 }
7123}
7124
7125// -----------------------------------------------------------------------------
7126
7127STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7128: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7129{
7130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7131 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7132
7133}
7134
7136{
7137 double BrHXXRatio = 1.0;
7138 if (fstate == 1){
7139 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7140 } else if (fstate == 2){
7141 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7142 } else if (fstate == 3){
7143 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7144 } else if (fstate == 4){
7145 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7146 } else {
7147 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7148 }
7149
7150 if ((this->getModel()).isModelLinearized()) {
7151 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7152 } else {
7153 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7154 }
7155}
7156
7157
7158// -----------------------------------------------------------------------------
7159
7160STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7161: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7162{
7163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7164 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7165
7166}
7167
7169{
7170 //-- Production:
7171 double weight = 1.0; //If normalized to the SM
7172
7173 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7174 double muProd1 = muProd -1.0;
7175 double muProd2 = 0.0;
7176 //-- Decay:
7177 double BrHXXRatio = 1.0;
7178 double dBrHXXRatio1 = 0.0;
7179 double dBrHXXRatio2 = 0.0;
7180
7181 if (fstate == 1){
7182 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7183 dBrHXXRatio1 = BrHXXRatio - 1.0;
7184 dBrHXXRatio2 = 0.0;
7185 } else if (fstate == 2){
7186 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7187 dBrHXXRatio1 = BrHXXRatio - 1.0;
7188 dBrHXXRatio2 = 0.0;
7189 } else if (fstate == 3){
7190 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7191 dBrHXXRatio1 = BrHXXRatio - 1.0;
7192 dBrHXXRatio2 = 0.0;
7193 } else if (fstate == 4){
7194 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7195 dBrHXXRatio1 = BrHXXRatio - 1.0;
7196 dBrHXXRatio2 = 0.0;
7197 } else {
7198 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7199 }
7200
7201 //-- Production x Decay:
7202 if ((this->getModel()).isModelLinearized()){
7203 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7204 } else if((this->getModel()).isModelNPquadratic()){
7205 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7206 } else {
7207 return weight*(muProd)*(BrHXXRatio);
7208 }
7209}
7210
7211
7212
7213
7214
7215// -----------------------------------------------------------------------------
7216
7217//VM:STXS2024;
7218STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7219: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7220{
7221 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7222 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7223
7224}
7225
7227{
7228 //-- Production:
7229 double weight = 1.0; //If normalized to the SM
7230 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7231 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7232 double muProd1 = muProd -1.0;
7233 double muProd2 = 0.0;
7234
7235 //-- Decay:
7236 double BrHXXRatio = 1.0;
7237 double dBrHXXRatio1 = 0.0;
7238 double dBrHXXRatio2 = 0.0;
7239 if (fstate==0){
7240 // Use for Cross-section [pb] with no Higgs-boson decay
7241 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7242 } else if (fstate == 1){
7243 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7244 dBrHXXRatio1 = BrHXXRatio - 1.0;
7245 dBrHXXRatio2 = 0.0;
7246 } else if (fstate == 2){
7247 BrHXXRatio = (myNPbase->BrHgagaRatio());
7248 dBrHXXRatio1 = BrHXXRatio - 1.0;
7249 dBrHXXRatio2 = 0.0;
7250 } else if (fstate == 3){
7251 BrHXXRatio = (myNPbase->BrHbbRatio());
7252 dBrHXXRatio1 = BrHXXRatio - 1.0;
7253 dBrHXXRatio2 = 0.0;
7254 } else if (fstate == 4){
7255 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7256 dBrHXXRatio1 = BrHXXRatio - 1.0;
7257 dBrHXXRatio2 = 0.0;
7258 } else if (fstate == 5){
7259 BrHXXRatio = (myNPbase->BrHtautauRatio());
7260 dBrHXXRatio1 = BrHXXRatio - 1.0;
7261 dBrHXXRatio2 = 0.0;
7262 } else if (fstate == 6){
7263 BrHXXRatio = (myNPbase->BrHWWRatio());
7264 dBrHXXRatio1 = BrHXXRatio - 1.0;
7265 dBrHXXRatio2 = 0.0;
7266 } else if (fstate == 7){
7267 BrHXXRatio = (myNPbase->BrHZZRatio());
7268 dBrHXXRatio1 = BrHXXRatio - 1.0;
7269 dBrHXXRatio2 = 0.0;
7270 } else {
7271 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7272 }
7273
7274 //-- Production x Decay:
7275 if ((this->getModel()).isModelLinearized()){
7276 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7277 } else if((this->getModel()).isModelNPquadratic()){
7278 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7279 } else {
7280 return weight*(muProd)*(BrHXXRatio);
7281 }
7282
7283}
7284
7285
7286
7287// -----------------------------------------------------------------------------
7288
7289//VM:STXS2024;
7290STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7291: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7292{
7293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7294 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7295
7296}
7297
7299{
7300 //-- Production:
7301 double weight = 1.0; //If normalized to the SM
7302 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7303 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7304 double muProd1 = muProd -1.0;
7305 double muProd2 = 0.0;
7306
7307 //-- Decay:
7308 double BrHXXRatio = 1.0;
7309 double dBrHXXRatio1 = 0.0;
7310 double dBrHXXRatio2 = 0.0;
7311 if (fstate==0){
7312 // Use for Cross-section [pb] with no Higgs-boson decay
7313 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7314 } else if (fstate == 1){
7315 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7316 dBrHXXRatio1 = BrHXXRatio - 1.0;
7317 dBrHXXRatio2 = 0.0;
7318 } else if (fstate == 2){
7319 BrHXXRatio = (myNPbase->BrHgagaRatio());
7320 dBrHXXRatio1 = BrHXXRatio - 1.0;
7321 dBrHXXRatio2 = 0.0;
7322 } else if (fstate == 3){
7323 BrHXXRatio = (myNPbase->BrHbbRatio());
7324 dBrHXXRatio1 = BrHXXRatio - 1.0;
7325 dBrHXXRatio2 = 0.0;
7326 } else if (fstate == 4){
7327 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7328 dBrHXXRatio1 = BrHXXRatio - 1.0;
7329 dBrHXXRatio2 = 0.0;
7330 } else if (fstate == 5){
7331 BrHXXRatio = (myNPbase->BrHtautauRatio());
7332 dBrHXXRatio1 = BrHXXRatio - 1.0;
7333 dBrHXXRatio2 = 0.0;
7334 } else if (fstate == 6){
7335 BrHXXRatio = (myNPbase->BrHWWRatio());
7336 dBrHXXRatio1 = BrHXXRatio - 1.0;
7337 dBrHXXRatio2 = 0.0;
7338 } else if (fstate == 7){
7339 BrHXXRatio = (myNPbase->BrHZZRatio());
7340 dBrHXXRatio1 = BrHXXRatio - 1.0;
7341 dBrHXXRatio2 = 0.0;
7342 } else {
7343 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7344 }
7345
7346 //-- Production x Decay:
7347 if ((this->getModel()).isModelLinearized()){
7348 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7349 } else if((this->getModel()).isModelNPquadratic()){
7350 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7351 } else {
7352 return weight*(muProd)*(BrHXXRatio);
7353 }
7354
7355}
7356
7357
7358
7359
7360// -----------------------------------------------------------------------------
7361
7362//VM:STXS2024;
7363STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7364: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7365{
7366 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7367 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7368
7369}
7370
7372{
7373 //-- Production:
7374 double weight = 1.0; //If normalized to the SM
7375 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7376 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7378 /(6.6369 + 20.642);
7379 double muProd1 = muProd -1.0;
7380 double muProd2 = 0.0;
7381
7382 //-- Decay:
7383 double BrHXXRatio = 1.0;
7384 double dBrHXXRatio1 = 0.0;
7385 double dBrHXXRatio2 = 0.0;
7386 if (fstate==0){
7387 // Use for Cross-section [pb] with no Higgs-boson decay
7388 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7389 } else if (fstate == 1){
7390 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7391 dBrHXXRatio1 = BrHXXRatio - 1.0;
7392 dBrHXXRatio2 = 0.0;
7393 } else if (fstate == 2){
7394 BrHXXRatio = (myNPbase->BrHgagaRatio());
7395 dBrHXXRatio1 = BrHXXRatio - 1.0;
7396 dBrHXXRatio2 = 0.0;
7397 } else if (fstate == 3){
7398 BrHXXRatio = (myNPbase->BrHbbRatio());
7399 dBrHXXRatio1 = BrHXXRatio - 1.0;
7400 dBrHXXRatio2 = 0.0;
7401 } else if (fstate == 4){
7402 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7403 dBrHXXRatio1 = BrHXXRatio - 1.0;
7404 dBrHXXRatio2 = 0.0;
7405 } else if (fstate == 5){
7406 BrHXXRatio = (myNPbase->BrHtautauRatio());
7407 dBrHXXRatio1 = BrHXXRatio - 1.0;
7408 dBrHXXRatio2 = 0.0;
7409 } else if (fstate == 6){
7410 BrHXXRatio = (myNPbase->BrHWWRatio());
7411 dBrHXXRatio1 = BrHXXRatio - 1.0;
7412 dBrHXXRatio2 = 0.0;
7413 } else if (fstate == 7){
7414 BrHXXRatio = (myNPbase->BrHZZRatio());
7415 dBrHXXRatio1 = BrHXXRatio - 1.0;
7416 dBrHXXRatio2 = 0.0;
7417 } else {
7418 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7419 }
7420
7421 //-- Production x Decay:
7422 if ((this->getModel()).isModelLinearized()){
7423 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7424 } else if((this->getModel()).isModelNPquadratic()){
7425 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7426 } else {
7427 return weight*(muProd)*(BrHXXRatio);
7428 }
7429
7430}
7431
7432
7433
7434
7435// -----------------------------------------------------------------------------
7436
7437//VM:STXS2024;
7438STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7439: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7440{
7441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7442 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7443
7444}
7445
7447{
7448 //-- Production:
7449 double weight = 1.0; //If normalized to the SM
7450 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7451
7452 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7453 double muProd1 = muProd -1.0;
7454 double muProd2 = 0.0;
7455
7456 //-- Decay:
7457 double BrHXXRatio = 1.0;
7458 double dBrHXXRatio1 = 0.0;
7459 double dBrHXXRatio2 = 0.0;
7460 if (fstate==0){
7461 // Use for Cross-section [pb] with no Higgs-boson decay
7462 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7463 } else if (fstate == 1){
7464 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7465 dBrHXXRatio1 = BrHXXRatio - 1.0;
7466 dBrHXXRatio2 = 0.0;
7467 } else if (fstate == 2){
7468 BrHXXRatio = (myNPbase->BrHgagaRatio());
7469 dBrHXXRatio1 = BrHXXRatio - 1.0;
7470 dBrHXXRatio2 = 0.0;
7471 } else if (fstate == 3){
7472 BrHXXRatio = (myNPbase->BrHbbRatio());
7473 dBrHXXRatio1 = BrHXXRatio - 1.0;
7474 dBrHXXRatio2 = 0.0;
7475 } else if (fstate == 4){
7476 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7477 dBrHXXRatio1 = BrHXXRatio - 1.0;
7478 dBrHXXRatio2 = 0.0;
7479 } else if (fstate == 5){
7480 BrHXXRatio = (myNPbase->BrHtautauRatio());
7481 dBrHXXRatio1 = BrHXXRatio - 1.0;
7482 dBrHXXRatio2 = 0.0;
7483 } else if (fstate == 6){
7484 BrHXXRatio = (myNPbase->BrHWWRatio());
7485 dBrHXXRatio1 = BrHXXRatio - 1.0;
7486 dBrHXXRatio2 = 0.0;
7487 } else if (fstate == 7){
7488 BrHXXRatio = (myNPbase->BrHZZRatio());
7489 dBrHXXRatio1 = BrHXXRatio - 1.0;
7490 dBrHXXRatio2 = 0.0;
7491 } else {
7492 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7493 }
7494
7495 //-- Production x Decay:
7496 if ((this->getModel()).isModelLinearized()){
7497 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7498 } else if((this->getModel()).isModelNPquadratic()){
7499 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7500 } else {
7501 return weight*(muProd)*(BrHXXRatio);
7502 }
7503
7504}
7505
7506
7507
7508
7509
7510
7511
7512// -----------------------------------------------------------------------------
7513
7514//AG:STXS2024
7515STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7516: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7517{
7518 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7519 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7520
7521}
7522
7524{
7525 //-- Production:
7526 double weight = 1.0; //If normalized to the SM
7527 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7528 double muProd1 = muProd -1.0;
7529 double muProd2 = 0.0;
7530
7531 //-- Decay:
7532 double BrHXXRatio = 1.0;
7533 double dBrHXXRatio1 = 0.0;
7534 double dBrHXXRatio2 = 0.0;
7535 if (fstate==0){
7536 // Use for Cross-section [pb] with no Higgs-boson decay
7537 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7538 } else if (fstate == 1){
7539 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7540 dBrHXXRatio1 = BrHXXRatio - 1.0;
7541 dBrHXXRatio2 = 0.0;
7542 } else if (fstate == 2){
7543 BrHXXRatio = (myNPbase->BrHgagaRatio());
7544 dBrHXXRatio1 = BrHXXRatio - 1.0;
7545 dBrHXXRatio2 = 0.0;
7546 } else if (fstate == 3){
7547 BrHXXRatio = (myNPbase->BrHbbRatio());
7548 dBrHXXRatio1 = BrHXXRatio - 1.0;
7549 dBrHXXRatio2 = 0.0;
7550 } else if (fstate == 4){
7551 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7552 dBrHXXRatio1 = BrHXXRatio - 1.0;
7553 dBrHXXRatio2 = 0.0;
7554 } else if (fstate == 5){
7555 BrHXXRatio = (myNPbase->BrHtautauRatio());
7556 dBrHXXRatio1 = BrHXXRatio - 1.0;
7557 dBrHXXRatio2 = 0.0;
7558 } else if (fstate == 6){
7559 BrHXXRatio = (myNPbase->BrHWWRatio());
7560 dBrHXXRatio1 = BrHXXRatio - 1.0;
7561 dBrHXXRatio2 = 0.0;
7562 } else if (fstate == 7){
7563 BrHXXRatio = (myNPbase->BrHZZRatio());
7564 dBrHXXRatio1 = BrHXXRatio - 1.0;
7565 dBrHXXRatio2 = 0.0;
7566 } else {
7567 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7568 }
7569
7570 //-- Production x Decay:
7571 if ((this->getModel()).isModelLinearized()){
7572 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7573 } else if((this->getModel()).isModelNPquadratic()){
7574 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7575 } else {
7576 return weight*(muProd)*(BrHXXRatio);
7577 }
7578
7579}
7580
7581// -----------------------------------------------------------------------------
7582
7583//AG:STXS2024
7584STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7585: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7586{
7587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7588 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7589
7590}
7591
7593{
7594 //-- Production:
7595 double weight = 1.0; //If normalized to the SM
7596 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7597 double muProd1 = muProd -1.0;
7598 double muProd2 = 0.0;
7599
7600 //-- Decay:
7601 double BrHXXRatio = 1.0;
7602 double dBrHXXRatio1 = 0.0;
7603 double dBrHXXRatio2 = 0.0;
7604 if (fstate==0){
7605 // Use for Cross-section [pb] with no Higgs-boson decay
7606 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7607 } else if (fstate == 1){
7608 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7609 dBrHXXRatio1 = BrHXXRatio - 1.0;
7610 dBrHXXRatio2 = 0.0;
7611 } else if (fstate == 2){
7612 BrHXXRatio = (myNPbase->BrHgagaRatio());
7613 dBrHXXRatio1 = BrHXXRatio - 1.0;
7614 dBrHXXRatio2 = 0.0;
7615 } else if (fstate == 3){
7616 BrHXXRatio = (myNPbase->BrHbbRatio());
7617 dBrHXXRatio1 = BrHXXRatio - 1.0;
7618 dBrHXXRatio2 = 0.0;
7619 } else if (fstate == 4){
7620 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7621 dBrHXXRatio1 = BrHXXRatio - 1.0;
7622 dBrHXXRatio2 = 0.0;
7623 } else if (fstate == 5){
7624 BrHXXRatio = (myNPbase->BrHtautauRatio());
7625 dBrHXXRatio1 = BrHXXRatio - 1.0;
7626 dBrHXXRatio2 = 0.0;
7627 } else if (fstate == 6){
7628 BrHXXRatio = (myNPbase->BrHWWRatio());
7629 dBrHXXRatio1 = BrHXXRatio - 1.0;
7630 dBrHXXRatio2 = 0.0;
7631 } else if (fstate == 7){
7632 BrHXXRatio = (myNPbase->BrHZZRatio());
7633 dBrHXXRatio1 = BrHXXRatio - 1.0;
7634 dBrHXXRatio2 = 0.0;
7635 } else {
7636 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7637 }
7638
7639 //-- Production x Decay:
7640 if ((this->getModel()).isModelLinearized()){
7641 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7642 } else if((this->getModel()).isModelNPquadratic()){
7643 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7644 } else {
7645 return weight*(muProd)*(BrHXXRatio);
7646 }
7647
7648}
7649
7650// -----------------------------------------------------------------------------
7651
7652//AG:STXS2024
7653STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7654: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7655{
7656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7657 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7658
7659}
7660
7662{
7663 //-- Production:
7664 double weight = 1.0; //If normalized to the SM
7665 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7666 double muProd1 = muProd -1.0;
7667 double muProd2 = 0.0;
7668
7669 //-- Decay:
7670 double BrHXXRatio = 1.0;
7671 double dBrHXXRatio1 = 0.0;
7672 double dBrHXXRatio2 = 0.0;
7673 if (fstate==0){
7674 // Use for Cross-section [pb] with no Higgs-boson decay
7675 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7676 } else if (fstate == 1){
7677 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7678 dBrHXXRatio1 = BrHXXRatio - 1.0;
7679 dBrHXXRatio2 = 0.0;
7680 } else if (fstate == 2){
7681 BrHXXRatio = (myNPbase->BrHgagaRatio());
7682 dBrHXXRatio1 = BrHXXRatio - 1.0;
7683 dBrHXXRatio2 = 0.0;
7684 } else if (fstate == 3){
7685 BrHXXRatio = (myNPbase->BrHbbRatio());
7686 dBrHXXRatio1 = BrHXXRatio - 1.0;
7687 dBrHXXRatio2 = 0.0;
7688 } else if (fstate == 4){
7689 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7690 dBrHXXRatio1 = BrHXXRatio - 1.0;
7691 dBrHXXRatio2 = 0.0;
7692 } else if (fstate == 5){
7693 BrHXXRatio = (myNPbase->BrHtautauRatio());
7694 dBrHXXRatio1 = BrHXXRatio - 1.0;
7695 dBrHXXRatio2 = 0.0;
7696 } else if (fstate == 6){
7697 BrHXXRatio = (myNPbase->BrHWWRatio());
7698 dBrHXXRatio1 = BrHXXRatio - 1.0;
7699 dBrHXXRatio2 = 0.0;
7700 } else if (fstate == 7){
7701 BrHXXRatio = (myNPbase->BrHZZRatio());
7702 dBrHXXRatio1 = BrHXXRatio - 1.0;
7703 dBrHXXRatio2 = 0.0;
7704 } else {
7705 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7706 }
7707
7708 //-- Production x Decay:
7709 if ((this->getModel()).isModelLinearized()){
7710 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7711 } else if((this->getModel()).isModelNPquadratic()){
7712 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7713 } else {
7714 return weight*(muProd)*(BrHXXRatio);
7715 }
7716
7717}
7718
7719// -----------------------------------------------------------------------------
7720
7721STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7722: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7723{
7724 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7725 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7726
7727}
7728
7730{
7731 double BrHXXRatio = 1.0;
7732 if (fstate == 1){
7733 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7734 } else if (fstate == 2){
7735 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7736 } else if (fstate == 3){
7737 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7738 } else if (fstate == 4){
7739 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7740 } else {
7741 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7742 }
7743
7744 if ((this->getModel()).isModelLinearized()) {
7745 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7746 } else {
7747 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7748 }
7749}
7750
7751// -----------------------------------------------------------------------------
7752
7753STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7754: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7755{
7756 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7757 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7758
7759}
7760
7762{
7763 double BrHXXRatio = 1.0;
7764 if (fstate == 1){
7765 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7766 } else if (fstate == 2){
7767 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7768 } else if (fstate == 3){
7769 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7770 } else if (fstate == 4){
7771 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7772 } else {
7773 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7774 }
7775
7776 if ((this->getModel()).isModelLinearized()) {
7777 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7778 } else {
7779 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7780 }
7781}
7782
7783
7784
7785
7786
7787// -----------------------------------------------------------------------------
7788
7789//VM:STXS2024;
7790STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7791: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7792{
7793 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7794 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7795
7796}
7797
7799{
7800 //-- Production:
7801 double weight = 1.0; //If normalized to the SM
7802 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7803 //We should weight each xsection with the SM prediction. We need to check
7804 //this values, nevertheless, the difference between the two parametrisations
7805 //is extremely small (way beyond our current precision)
7806 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7808 /(2.);
7809 double muProd1 = muProd -1.0;
7810 double muProd2 = 0.0;
7811
7812 //-- Decay:
7813 double BrHXXRatio = 1.0;
7814 double dBrHXXRatio1 = 0.0;
7815 double dBrHXXRatio2 = 0.0;
7816 if (fstate==0){
7817 // Use for Cross-section [pb] with no Higgs-boson decay
7818 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7819 } else if (fstate == 1){
7820 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7821 dBrHXXRatio1 = BrHXXRatio - 1.0;
7822 dBrHXXRatio2 = 0.0;
7823 } else if (fstate == 2){
7824 BrHXXRatio = (myNPbase->BrHgagaRatio());
7825 dBrHXXRatio1 = BrHXXRatio - 1.0;
7826 dBrHXXRatio2 = 0.0;
7827 } else if (fstate == 3){
7828 BrHXXRatio = (myNPbase->BrHbbRatio());
7829 dBrHXXRatio1 = BrHXXRatio - 1.0;
7830 dBrHXXRatio2 = 0.0;
7831 } else if (fstate == 4){
7832 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7833 dBrHXXRatio1 = BrHXXRatio - 1.0;
7834 dBrHXXRatio2 = 0.0;
7835 } else if (fstate == 5){
7836 BrHXXRatio = (myNPbase->BrHtautauRatio());
7837 dBrHXXRatio1 = BrHXXRatio - 1.0;
7838 dBrHXXRatio2 = 0.0;
7839 } else if (fstate == 6){
7840 BrHXXRatio = (myNPbase->BrHWWRatio());
7841 dBrHXXRatio1 = BrHXXRatio - 1.0;
7842 dBrHXXRatio2 = 0.0;
7843 } else if (fstate == 7){
7844 BrHXXRatio = (myNPbase->BrHZZRatio());
7845 dBrHXXRatio1 = BrHXXRatio - 1.0;
7846 dBrHXXRatio2 = 0.0;
7847 } else {
7848 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7849 }
7850
7851 //-- Production x Decay:
7852 if ((this->getModel()).isModelLinearized()){
7853 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7854 } else if((this->getModel()).isModelNPquadratic()){
7855 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7856 } else {
7857 return weight*(muProd)*(BrHXXRatio);
7858 }
7859
7860}
7861
7862
7863
7864
7865// -----------------------------------------------------------------------------
7866
7867//AG:STXS2024
7868STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7869: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7870{
7871 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7872 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7873
7874}
7875
7877{
7878 //-- Production:
7879 double weight = 1.0; //If normalized to the SM
7881 double muProd1 = muProd -1.0;
7882 double muProd2 = 0.0;
7883
7884 //-- Decay:
7885 double BrHXXRatio = 1.0;
7886 double dBrHXXRatio1 = 0.0;
7887 double dBrHXXRatio2 = 0.0;
7888 if (fstate==0){
7889 // Use for Cross-section [pb] with no Higgs-boson decay
7890 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7891 } else if (fstate == 1){
7892 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7893 dBrHXXRatio1 = BrHXXRatio - 1.0;
7894 dBrHXXRatio2 = 0.0;
7895 } else if (fstate == 2){
7896 BrHXXRatio = (myNPbase->BrHgagaRatio());
7897 dBrHXXRatio1 = BrHXXRatio - 1.0;
7898 dBrHXXRatio2 = 0.0;
7899 } else if (fstate == 3){
7900 BrHXXRatio = (myNPbase->BrHbbRatio());
7901 dBrHXXRatio1 = BrHXXRatio - 1.0;
7902 dBrHXXRatio2 = 0.0;
7903 } else if (fstate == 4){
7904 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7905 dBrHXXRatio1 = BrHXXRatio - 1.0;
7906 dBrHXXRatio2 = 0.0;
7907 } else if (fstate == 5){
7908 BrHXXRatio = (myNPbase->BrHtautauRatio());
7909 dBrHXXRatio1 = BrHXXRatio - 1.0;
7910 dBrHXXRatio2 = 0.0;
7911 }else {
7912 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7913 }
7914
7915 //-- Production x Decay:
7916 if ((this->getModel()).isModelLinearized()){
7917 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7918 } else if((this->getModel()).isModelNPquadratic()){
7919 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7920 } else {
7921 return weight*(muProd)*(BrHXXRatio);
7922 }
7923
7924}
7925
7926
7927
7928
7929//VM:STXS2024;
7930STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7931: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7932{
7933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7934 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7935
7936}
7937
7939{
7940 //-- Production:
7941 double weight = 1.0; //If normalized to the SM
7942 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7943 //We should weight each xsection with the SM prediction. We need to check
7944 //this values, nevertheless, the difference between the two parametrisations
7945 //is extremely small (way beyond our current precision)
7948 /(2.);
7949 double muProd1 = muProd -1.0;
7950 double muProd2 = 0.0;
7951
7952 //-- Decay:
7953 double BrHXXRatio = 1.0;
7954 double dBrHXXRatio1 = 0.0;
7955 double dBrHXXRatio2 = 0.0;
7956 if (fstate==0){
7957 // Use for Cross-section [pb] with no Higgs-boson decay
7958 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7959 } else if (fstate == 1){
7960 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7961 dBrHXXRatio1 = BrHXXRatio - 1.0;
7962 dBrHXXRatio2 = 0.0;
7963 } else if (fstate == 2){
7964 BrHXXRatio = (myNPbase->BrHgagaRatio());
7965 dBrHXXRatio1 = BrHXXRatio - 1.0;
7966 dBrHXXRatio2 = 0.0;
7967 } else if (fstate == 3){
7968 BrHXXRatio = (myNPbase->BrHbbRatio());
7969 dBrHXXRatio1 = BrHXXRatio - 1.0;
7970 dBrHXXRatio2 = 0.0;
7971 } else if (fstate == 4){
7972 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7973 dBrHXXRatio1 = BrHXXRatio - 1.0;
7974 dBrHXXRatio2 = 0.0;
7975 } else if (fstate == 5){
7976 BrHXXRatio = (myNPbase->BrHtautauRatio());
7977 dBrHXXRatio1 = BrHXXRatio - 1.0;
7978 dBrHXXRatio2 = 0.0;
7979 } else if (fstate == 6){
7980 BrHXXRatio = (myNPbase->BrHWWRatio());
7981 dBrHXXRatio1 = BrHXXRatio - 1.0;
7982 dBrHXXRatio2 = 0.0;
7983 } else if (fstate == 7){
7984 BrHXXRatio = (myNPbase->BrHZZRatio());
7985 dBrHXXRatio1 = BrHXXRatio - 1.0;
7986 dBrHXXRatio2 = 0.0;
7987 } else {
7988 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7989 }
7990
7991 //-- Production x Decay:
7992 if ((this->getModel()).isModelLinearized()){
7993 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7994 } else if((this->getModel()).isModelNPquadratic()){
7995 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7996 } else {
7997 return weight*(muProd)*(BrHXXRatio);
7998 }
7999
8000}
8001
8002
8003// -----------------------------------------------------------------------------
8004
8006: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8007{
8008 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8009 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8010
8011}
8012
8014{
8015 double BrHXXRatio = 1.0;
8016 if (fstate == 1){
8017 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8018 } else if (fstate == 2){
8019 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8020 } else if (fstate == 3){
8021 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8022 } else if (fstate == 4){
8023 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8024 } else {
8025 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8026 }
8027
8028 if ((this->getModel()).isModelLinearized()) {
8029 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8030 } else {
8032 }
8033}
8034
8035// -----------------------------------------------------------------------------
8036
8038: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8039{
8040
8041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8042 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8043
8044}
8045
8047{
8048 double BrHXXRatio = 1.0;
8049 if (fstate == 1){
8050 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8051 } else if (fstate == 2){
8052 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8053 } else if (fstate == 3){
8054 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8055 } else if (fstate == 4){
8056 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8057 } else {
8058 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8059 }
8060
8061 if ((this->getModel()).isModelLinearized()) {
8062 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8063 } else {
8065 }
8066}
8067
8068// -----------------------------------------------------------------------------
8069
8071: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8072{
8073 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8074 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8075
8076}
8077
8079{
8080 double BrHXXRatio = 1.0;
8081 if (fstate == 1){
8082 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8083 } else if (fstate == 2){
8084 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8085 } else if (fstate == 3){
8086 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8087 } else if (fstate == 4){
8088 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8089 } else {
8090 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8091 }
8092
8093 if ((this->getModel()).isModelLinearized()) {
8094 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8095 } else {
8097 }
8098}
8099
8100// -----------------------------------------------------------------------------
8101
8103: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8104{
8105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8106 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8107
8108}
8109
8111{
8112 double BrHXXRatio = 1.0;
8113 if (fstate == 1){
8114 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8115 } else if (fstate == 2){
8116 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8117 } else if (fstate == 3){
8118 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8119 } else if (fstate == 4){
8120 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8121 } else {
8122 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8123 }
8124
8125 if ((this->getModel()).isModelLinearized()) {
8126 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8127 } else {
8129 }
8130}
8131
8132
8133
8134
8135
8136// -----------------------------------------------------------------------------
8137
8138//VM:STXS2024;
8139STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8140: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8141{
8142 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8143 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8144
8145}
8146
8148{
8149
8150
8151
8152 //-- Production:
8153 double weight = 1.0; //If normalized to the SM
8154 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8155 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8156 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8157 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8158 //The possible error that we could be introducing here is way below our precision!
8159 double muProd = (
8163 )/(2.9636+0.94321+0.87751);
8164 double muProd1 = muProd -1.0;
8165 double muProd2 = 0.0;
8166
8167 //-- Decay:
8168 double BrHXXRatio = 1.0;
8169 double dBrHXXRatio1 = 0.0;
8170 double dBrHXXRatio2 = 0.0;
8171 if (fstate==0){
8172 // Use for Cross-section [pb] with no Higgs-boson decay
8173 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8174 } else if (fstate == 1){
8175 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8176 dBrHXXRatio1 = BrHXXRatio - 1.0;
8177 dBrHXXRatio2 = 0.0;
8178 } else if (fstate == 2){
8179 BrHXXRatio = (myNPbase->BrHgagaRatio());
8180 dBrHXXRatio1 = BrHXXRatio - 1.0;
8181 dBrHXXRatio2 = 0.0;
8182 } else if (fstate == 3){
8183 BrHXXRatio = (myNPbase->BrHbbRatio());
8184 dBrHXXRatio1 = BrHXXRatio - 1.0;
8185 dBrHXXRatio2 = 0.0;
8186 } else if (fstate == 4){
8187 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8188 dBrHXXRatio1 = BrHXXRatio - 1.0;
8189 dBrHXXRatio2 = 0.0;
8190 } else if (fstate == 5){
8191 BrHXXRatio = (myNPbase->BrHtautauRatio());
8192 dBrHXXRatio1 = BrHXXRatio - 1.0;
8193 dBrHXXRatio2 = 0.0;
8194 } else if (fstate == 6){
8195 BrHXXRatio = (myNPbase->BrHWWRatio());
8196 dBrHXXRatio1 = BrHXXRatio - 1.0;
8197 dBrHXXRatio2 = 0.0;
8198 } else if (fstate == 7){
8199 BrHXXRatio = (myNPbase->BrHZZRatio());
8200 dBrHXXRatio1 = BrHXXRatio - 1.0;
8201 dBrHXXRatio2 = 0.0;
8202 } else {
8203 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8204 }
8205
8206 //-- Production x Decay:
8207 if ((this->getModel()).isModelLinearized()){
8208 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8209 } else if((this->getModel()).isModelNPquadratic()){
8210 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8211 } else {
8212 return weight*(muProd)*(BrHXXRatio);
8213 }
8214
8215}
8216
8217
8218
8219
8220
8221
8222
8223// -----------------------------------------------------------------------------
8224
8225
8226//VM:STXS2024;
8227STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8228: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8229{
8230 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8231 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8232
8233}
8234
8236{
8237 //-- Production:
8238 double weight = 1.0; //If normalized to the SM
8239 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8240 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8243 /(0.45825 + 0.10632 + 0.017974);
8244 double muProd1 = muProd -1.0;
8245 double muProd2 = 0.0;
8246
8247 //-- Decay:
8248 double BrHXXRatio = 1.0;
8249 double dBrHXXRatio1 = 0.0;
8250 double dBrHXXRatio2 = 0.0;
8251 if (fstate==0){
8252 // Use for Cross-section [pb] with no Higgs-boson decay
8253 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8254 } else if (fstate == 1){
8255 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8256 dBrHXXRatio1 = BrHXXRatio - 1.0;
8257 dBrHXXRatio2 = 0.0;
8258 } else if (fstate == 2){
8259 BrHXXRatio = (myNPbase->BrHgagaRatio());
8260 dBrHXXRatio1 = BrHXXRatio - 1.0;
8261 dBrHXXRatio2 = 0.0;
8262 } else if (fstate == 3){
8263 BrHXXRatio = (myNPbase->BrHbbRatio());
8264 dBrHXXRatio1 = BrHXXRatio - 1.0;
8265 dBrHXXRatio2 = 0.0;
8266 } else if (fstate == 4){
8267 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8268 dBrHXXRatio1 = BrHXXRatio - 1.0;
8269 dBrHXXRatio2 = 0.0;
8270 } else if (fstate == 5){
8271 BrHXXRatio = (myNPbase->BrHtautauRatio());
8272 dBrHXXRatio1 = BrHXXRatio - 1.0;
8273 dBrHXXRatio2 = 0.0;
8274 } else if (fstate == 6){
8275 BrHXXRatio = (myNPbase->BrHWWRatio());
8276 dBrHXXRatio1 = BrHXXRatio - 1.0;
8277 dBrHXXRatio2 = 0.0;
8278 } else if (fstate == 7){
8279 BrHXXRatio = (myNPbase->BrHZZRatio());
8280 dBrHXXRatio1 = BrHXXRatio - 1.0;
8281 dBrHXXRatio2 = 0.0;
8282 } else {
8283 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8284 }
8285
8286 //-- Production x Decay:
8287 if ((this->getModel()).isModelLinearized()){
8288 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8289 } else if((this->getModel()).isModelNPquadratic()){
8290 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8291 } else {
8292 return weight*(muProd)*(BrHXXRatio);
8293 }
8294
8295}
8296
8297
8298
8299
8300// -----------------------------------------------------------------------------
8301
8302
8303//VM:STXS2024;
8304STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8305: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8306{
8307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8308 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8309
8310}
8311
8313{
8314 //-- Production:
8315 double weight = 1.0; //If normalized to the SM
8316 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8317 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8319 /(0.10632 + 0.017974);
8320 double muProd1 = muProd -1.0;
8321 double muProd2 = 0.0;
8322
8323 //-- Decay:
8324 double BrHXXRatio = 1.0;
8325 double dBrHXXRatio1 = 0.0;
8326 double dBrHXXRatio2 = 0.0;
8327 if (fstate==0){
8328 // Use for Cross-section [pb] with no Higgs-boson decay
8329 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8330 } else if (fstate == 1){
8331 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8332 dBrHXXRatio1 = BrHXXRatio - 1.0;
8333 dBrHXXRatio2 = 0.0;
8334 } else if (fstate == 2){
8335 BrHXXRatio = (myNPbase->BrHgagaRatio());
8336 dBrHXXRatio1 = BrHXXRatio - 1.0;
8337 dBrHXXRatio2 = 0.0;
8338 } else if (fstate == 3){
8339 BrHXXRatio = (myNPbase->BrHbbRatio());
8340 dBrHXXRatio1 = BrHXXRatio - 1.0;
8341 dBrHXXRatio2 = 0.0;
8342 } else if (fstate == 4){
8343 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8344 dBrHXXRatio1 = BrHXXRatio - 1.0;
8345 dBrHXXRatio2 = 0.0;
8346 } else if (fstate == 5){
8347 BrHXXRatio = (myNPbase->BrHtautauRatio());
8348 dBrHXXRatio1 = BrHXXRatio - 1.0;
8349 dBrHXXRatio2 = 0.0;
8350 } else if (fstate == 6){
8351 BrHXXRatio = (myNPbase->BrHWWRatio());
8352 dBrHXXRatio1 = BrHXXRatio - 1.0;
8353 dBrHXXRatio2 = 0.0;
8354 } else if (fstate == 7){
8355 BrHXXRatio = (myNPbase->BrHZZRatio());
8356 dBrHXXRatio1 = BrHXXRatio - 1.0;
8357 dBrHXXRatio2 = 0.0;
8358 } else {
8359 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8360 }
8361
8362 //-- Production x Decay:
8363 if ((this->getModel()).isModelLinearized()){
8364 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8365 } else if((this->getModel()).isModelNPquadratic()){
8366 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8367 } else {
8368 return weight*(muProd)*(BrHXXRatio);
8369 }
8370
8371}
8372
8373
8374// -----------------------------------------------------------------------------
8375
8376
8377//VM:STXS2024;
8378STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8379: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8380{
8381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8382 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8383
8384}
8385
8387{
8388 //-- Production:
8389 double weight = 1.0; //If normalized to the SM
8390 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8391 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8392 double muProd1 = muProd -1.0;
8393 double muProd2 = 0.0;
8394
8395 //-- Decay:
8396 double BrHXXRatio = 1.0;
8397 double dBrHXXRatio1 = 0.0;
8398 double dBrHXXRatio2 = 0.0;
8399 if (fstate==0){
8400 // Use for Cross-section [pb] with no Higgs-boson decay
8401 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8402 } else if (fstate == 1){
8403 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8404 dBrHXXRatio1 = BrHXXRatio - 1.0;
8405 dBrHXXRatio2 = 0.0;
8406 } else if (fstate == 2){
8407 BrHXXRatio = (myNPbase->BrHgagaRatio());
8408 dBrHXXRatio1 = BrHXXRatio - 1.0;
8409 dBrHXXRatio2 = 0.0;
8410 } else if (fstate == 3){
8411 BrHXXRatio = (myNPbase->BrHbbRatio());
8412 dBrHXXRatio1 = BrHXXRatio - 1.0;
8413 dBrHXXRatio2 = 0.0;
8414 } else if (fstate == 4){
8415 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8416 dBrHXXRatio1 = BrHXXRatio - 1.0;
8417 dBrHXXRatio2 = 0.0;
8418 } else if (fstate == 5){
8419 BrHXXRatio = (myNPbase->BrHtautauRatio());
8420 dBrHXXRatio1 = BrHXXRatio - 1.0;
8421 dBrHXXRatio2 = 0.0;
8422 } else if (fstate == 6){
8423 BrHXXRatio = (myNPbase->BrHWWRatio());
8424 dBrHXXRatio1 = BrHXXRatio - 1.0;
8425 dBrHXXRatio2 = 0.0;
8426 } else if (fstate == 7){
8427 BrHXXRatio = (myNPbase->BrHZZRatio());
8428 dBrHXXRatio1 = BrHXXRatio - 1.0;
8429 dBrHXXRatio2 = 0.0;
8430 } else {
8431 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8432 }
8433
8434 //-- Production x Decay:
8435 if ((this->getModel()).isModelLinearized()){
8436 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8437 } else if((this->getModel()).isModelNPquadratic()){
8438 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8439 } else {
8440 return weight*(muProd)*(BrHXXRatio);
8441 }
8442
8443}
8444
8445
8446
8447// -----------------------------------------------------------------------------
8448
8449
8450//VM:STXS2024;
8451STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8452: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8453{
8454 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8455 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8456
8457}
8458
8460{
8461 //-- Production:
8462 double weight = 1.0; //If normalized to the SM
8463 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8464 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8465 double muProd1 = muProd -1.0;
8466 double muProd2 = 0.0;
8467
8468 //-- Decay:
8469 double BrHXXRatio = 1.0;
8470 double dBrHXXRatio1 = 0.0;
8471 double dBrHXXRatio2 = 0.0;
8472 if (fstate==0){
8473 // Use for Cross-section [pb] with no Higgs-boson decay
8474 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8475 } else if (fstate == 1){
8476 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8477 dBrHXXRatio1 = BrHXXRatio - 1.0;
8478 dBrHXXRatio2 = 0.0;
8479 } else if (fstate == 2){
8480 BrHXXRatio = (myNPbase->BrHgagaRatio());
8481 dBrHXXRatio1 = BrHXXRatio - 1.0;
8482 dBrHXXRatio2 = 0.0;
8483 } else if (fstate == 3){
8484 BrHXXRatio = (myNPbase->BrHbbRatio());
8485 dBrHXXRatio1 = BrHXXRatio - 1.0;
8486 dBrHXXRatio2 = 0.0;
8487 } else if (fstate == 4){
8488 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8489 dBrHXXRatio1 = BrHXXRatio - 1.0;
8490 dBrHXXRatio2 = 0.0;
8491 } else if (fstate == 5){
8492 BrHXXRatio = (myNPbase->BrHtautauRatio());
8493 dBrHXXRatio1 = BrHXXRatio - 1.0;
8494 dBrHXXRatio2 = 0.0;
8495 } else if (fstate == 6){
8496 BrHXXRatio = (myNPbase->BrHWWRatio());
8497 dBrHXXRatio1 = BrHXXRatio - 1.0;
8498 dBrHXXRatio2 = 0.0;
8499 } else if (fstate == 7){
8500 BrHXXRatio = (myNPbase->BrHZZRatio());
8501 dBrHXXRatio1 = BrHXXRatio - 1.0;
8502 dBrHXXRatio2 = 0.0;
8503 } else {
8504 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8505 }
8506
8507 //-- Production x Decay:
8508 if ((this->getModel()).isModelLinearized()){
8509 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8510 } else if((this->getModel()).isModelNPquadratic()){
8511 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8512 } else {
8513 return weight*(muProd)*(BrHXXRatio);
8514 }
8515
8516}
8517
8518
8519
8520
8521// -----------------------------------------------------------------------------
8522
8523
8524//VM:STXS2024;
8525STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8526: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8527{
8528 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8529 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8530
8531}
8532
8534{
8535 //-- Production:
8536 double weight = 1.0; //If normalized to the SM
8537 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8538 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8539 double muProd1 = muProd -1.0;
8540 double muProd2 = 0.0;
8541
8542 //-- Decay:
8543 double BrHXXRatio = 1.0;
8544 double dBrHXXRatio1 = 0.0;
8545 double dBrHXXRatio2 = 0.0;
8546 if (fstate==0){
8547 // Use for Cross-section [pb] with no Higgs-boson decay
8548 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8549 } else if (fstate == 1){
8550 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8551 dBrHXXRatio1 = BrHXXRatio - 1.0;
8552 dBrHXXRatio2 = 0.0;
8553 } else if (fstate == 2){
8554 BrHXXRatio = (myNPbase->BrHgagaRatio());
8555 dBrHXXRatio1 = BrHXXRatio - 1.0;
8556 dBrHXXRatio2 = 0.0;
8557 } else if (fstate == 3){
8558 BrHXXRatio = (myNPbase->BrHbbRatio());
8559 dBrHXXRatio1 = BrHXXRatio - 1.0;
8560 dBrHXXRatio2 = 0.0;
8561 } else if (fstate == 4){
8562 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8563 dBrHXXRatio1 = BrHXXRatio - 1.0;
8564 dBrHXXRatio2 = 0.0;
8565 } else if (fstate == 5){
8566 BrHXXRatio = (myNPbase->BrHtautauRatio());
8567 dBrHXXRatio1 = BrHXXRatio - 1.0;
8568 dBrHXXRatio2 = 0.0;
8569 } else if (fstate == 6){
8570 BrHXXRatio = (myNPbase->BrHWWRatio());
8571 dBrHXXRatio1 = BrHXXRatio - 1.0;
8572 dBrHXXRatio2 = 0.0;
8573 } else if (fstate == 7){
8574 BrHXXRatio = (myNPbase->BrHZZRatio());
8575 dBrHXXRatio1 = BrHXXRatio - 1.0;
8576 dBrHXXRatio2 = 0.0;
8577 } else {
8578 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8579 }
8580
8581 //-- Production x Decay:
8582 if ((this->getModel()).isModelLinearized()){
8583 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8584 } else if((this->getModel()).isModelNPquadratic()){
8585 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8586 } else {
8587 return weight*(muProd)*(BrHXXRatio);
8588 }
8589
8590}
8591
8592
8593
8594// -----------------------------------------------------------------------------
8595
8596
8597//VM:STXS2024;
8598STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8599: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8600{
8601 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8602 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8603
8604}
8605
8607{
8608 //-- Production:
8609 double weight = 1.0; //If normalized to the SM
8610 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8611 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8612 double muProd1 = muProd -1.0;
8613 double muProd2 = 0.0;
8614
8615 //-- Decay:
8616 double BrHXXRatio = 1.0;
8617 double dBrHXXRatio1 = 0.0;
8618 double dBrHXXRatio2 = 0.0;
8619 if (fstate==0){
8620 // Use for Cross-section [pb] with no Higgs-boson decay
8621 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8622 } else if (fstate == 1){
8623 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8624 dBrHXXRatio1 = BrHXXRatio - 1.0;
8625 dBrHXXRatio2 = 0.0;
8626 } else if (fstate == 2){
8627 BrHXXRatio = (myNPbase->BrHgagaRatio());
8628 dBrHXXRatio1 = BrHXXRatio - 1.0;
8629 dBrHXXRatio2 = 0.0;
8630 } else if (fstate == 3){
8631 BrHXXRatio = (myNPbase->BrHbbRatio());
8632 dBrHXXRatio1 = BrHXXRatio - 1.0;
8633 dBrHXXRatio2 = 0.0;
8634 } else if (fstate == 4){
8635 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8636 dBrHXXRatio1 = BrHXXRatio - 1.0;
8637 dBrHXXRatio2 = 0.0;
8638 } else if (fstate == 5){
8639 BrHXXRatio = (myNPbase->BrHtautauRatio());
8640 dBrHXXRatio1 = BrHXXRatio - 1.0;
8641 dBrHXXRatio2 = 0.0;
8642 } else if (fstate == 6){
8643 BrHXXRatio = (myNPbase->BrHWWRatio());
8644 dBrHXXRatio1 = BrHXXRatio - 1.0;
8645 dBrHXXRatio2 = 0.0;
8646 } else if (fstate == 7){
8647 BrHXXRatio = (myNPbase->BrHZZRatio());
8648 dBrHXXRatio1 = BrHXXRatio - 1.0;
8649 dBrHXXRatio2 = 0.0;
8650 } else {
8651 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8652 }
8653
8654 //-- Production x Decay:
8655 if ((this->getModel()).isModelLinearized()){
8656 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8657 } else if((this->getModel()).isModelNPquadratic()){
8658 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8659 } else {
8660 return weight*(muProd)*(BrHXXRatio);
8661 }
8662
8663}
8664
8665
8666
8667// -----------------------------------------------------------------------------
8668
8669
8670//VM:STXS2024;
8671STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8672: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8673{
8674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8675 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8676
8677}
8678
8680{
8681 //-- Production:
8682 double weight = 1.0; //If normalized to the SM
8683 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8684 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8685 double muProd1 = muProd -1.0;
8686 double muProd2 = 0.0;
8687
8688 //-- Decay:
8689 double BrHXXRatio = 1.0;
8690 double dBrHXXRatio1 = 0.0;
8691 double dBrHXXRatio2 = 0.0;
8692 if (fstate==0){
8693 // Use for Cross-section [pb] with no Higgs-boson decay
8694 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8695 } else if (fstate == 1){
8696 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8697 dBrHXXRatio1 = BrHXXRatio - 1.0;
8698 dBrHXXRatio2 = 0.0;
8699 } else if (fstate == 2){
8700 BrHXXRatio = (myNPbase->BrHgagaRatio());
8701 dBrHXXRatio1 = BrHXXRatio - 1.0;
8702 dBrHXXRatio2 = 0.0;
8703 } else if (fstate == 3){
8704 BrHXXRatio = (myNPbase->BrHbbRatio());
8705 dBrHXXRatio1 = BrHXXRatio - 1.0;
8706 dBrHXXRatio2 = 0.0;
8707 } else if (fstate == 4){
8708 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8709 dBrHXXRatio1 = BrHXXRatio - 1.0;
8710 dBrHXXRatio2 = 0.0;
8711 } else if (fstate == 5){
8712 BrHXXRatio = (myNPbase->BrHtautauRatio());
8713 dBrHXXRatio1 = BrHXXRatio - 1.0;
8714 dBrHXXRatio2 = 0.0;
8715 } else if (fstate == 6){
8716 BrHXXRatio = (myNPbase->BrHWWRatio());
8717 dBrHXXRatio1 = BrHXXRatio - 1.0;
8718 dBrHXXRatio2 = 0.0;
8719 } else if (fstate == 7){
8720 BrHXXRatio = (myNPbase->BrHZZRatio());
8721 dBrHXXRatio1 = BrHXXRatio - 1.0;
8722 dBrHXXRatio2 = 0.0;
8723 } else {
8724 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8725 }
8726
8727 //-- Production x Decay:
8728 if ((this->getModel()).isModelLinearized()){
8729 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8730 } else if((this->getModel()).isModelNPquadratic()){
8731 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8732 } else {
8733 return weight*(muProd)*(BrHXXRatio);
8734 }
8735
8736}
8737
8738
8739// -----------------------------------------------------------------------------
8740
8741STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8742: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8743{
8744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8745 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8746
8747}
8748
8750{
8751 double BrHXXRatio = 1.0;
8752 if (fstate == 1){
8753 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8754 } else if (fstate == 2){
8755 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8756 } else if (fstate == 3){
8757 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8758 } else if (fstate == 4){
8759 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8760 } else {
8761 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8762 }
8763
8764 if ((this->getModel()).isModelLinearized()) {
8765 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8766 } else {
8767 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8768 }
8769}
8770
8771// -----------------------------------------------------------------------------
8772
8773STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8774: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8775{
8776 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8777 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8778
8779}
8780
8782{
8783 double BrHXXRatio = 1.0;
8784 if (fstate == 1){
8785 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8786 } else if (fstate == 2){
8787 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8788 } else if (fstate == 3){
8789 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8790 } else if (fstate == 4){
8791 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8792 } else {
8793 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8794 }
8795
8796 if ((this->getModel()).isModelLinearized()) {
8797 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8798 } else {
8799 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8800 }
8801}
8802
8803// -----------------------------------------------------------------------------
8804
8805STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8806: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8807{
8808 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8809 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8810
8811}
8812
8814{
8815 double BrHXXRatio = 1.0;
8816 if (fstate == 1){
8817 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8818 } else if (fstate == 2){
8819 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8820 } else if (fstate == 3){
8821 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8822 } else if (fstate == 4){
8823 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8824 } else {
8825 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8826 }
8827
8828 if ((this->getModel()).isModelLinearized()) {
8829 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8830 } else {
8831 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8832 }
8833}
8834
8835// -----------------------------------------------------------------------------
8836
8837STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8838: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8839{
8840 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8841 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8842
8843}
8844
8846{
8847 double BrHXXRatio = 1.0;
8848 if (fstate == 1){
8849 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8850 } else if (fstate == 2){
8851 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8852 } else if (fstate == 3){
8853 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8854 } else if (fstate == 4){
8855 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8856 } else {
8857 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8858 }
8859
8860 if ((this->getModel()).isModelLinearized()) {
8861 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8862 } else {
8863 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8864 }
8865}
8866
8867// -----------------------------------------------------------------------------
8868
8869STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8870: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8871{
8872 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8873 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8874
8875}
8876
8878{
8879 double BrHXXRatio = 1.0;
8880 if (fstate == 1){
8881 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8882 } else if (fstate == 2){
8883 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8884 } else if (fstate == 3){
8885 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8886 } else if (fstate == 4){
8887 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8888 } else {
8889 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8890 }
8891
8892 if ((this->getModel()).isModelLinearized()) {
8893 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8894 } else {
8895 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8896 }
8897}
8898
8899// -----------------------------------------------------------------------------
8900
8901STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8902: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8903{
8904 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8905 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8906
8907}
8908
8910{
8911 double BrHXXRatio = 1.0;
8912 if (fstate == 1){
8913 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8914 } else if (fstate == 2){
8915 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8916 } else if (fstate == 3){
8917 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8918 } else if (fstate == 4){
8919 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8920 } else {
8921 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8922 }
8923
8924 if ((this->getModel()).isModelLinearized()) {
8925 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8926 } else {
8927 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8928 }
8929}
8930
8931// -----------------------------------------------------------------------------
8932
8933STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8934: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8935{
8936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8937 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8938
8939}
8940
8942{
8943 double BrHXXRatio = 1.0;
8944 if (fstate == 1){
8945 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8946 } else if (fstate == 2){
8947 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8948 } else if (fstate == 3){
8949 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8950 } else if (fstate == 4){
8951 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8952 } else {
8953 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8954 }
8955
8956 if ((this->getModel()).isModelLinearized()) {
8957 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8958 } else {
8959 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8960 }
8961}
8962
8963// -----------------------------------------------------------------------------
8964
8965STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8966: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8967{
8968 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8969 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8970
8971}
8972
8974{
8975 double BrHXXRatio = 1.0;
8976 if (fstate == 1){
8977 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8978 } else if (fstate == 2){
8979 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8980 } else if (fstate == 3){
8981 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8982 } else if (fstate == 4){
8983 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8984 } else {
8985 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8986 }
8987
8988 if ((this->getModel()).isModelLinearized()) {
8989 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8990 } else {
8991 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8992 }
8993}
8994
8995
8996
8997// -----------------------------------------------------------------------------
8998
8999
9000//VM:STXS2024;
9001STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9002: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9003{
9004 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9005 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9006
9007}
9008
9010{
9011 //-- Production:
9012 double weight = 1.0; //If normalized to the SM
9013 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9014 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
9015 double muProd1 = muProd -1.0;
9016 double muProd2 = 0.0;
9017
9018 //-- Decay:
9019 double BrHXXRatio = 1.0;
9020 double dBrHXXRatio1 = 0.0;
9021 double dBrHXXRatio2 = 0.0;
9022 if (fstate==0){
9023 // Use for Cross-section [pb] with no Higgs-boson decay
9024 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9025 } else if (fstate == 1){
9026 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9027 dBrHXXRatio1 = BrHXXRatio - 1.0;
9028 dBrHXXRatio2 = 0.0;
9029 } else if (fstate == 2){
9030 BrHXXRatio = (myNPbase->BrHgagaRatio());
9031 dBrHXXRatio1 = BrHXXRatio - 1.0;
9032 dBrHXXRatio2 = 0.0;
9033 } else if (fstate == 3){
9034 BrHXXRatio = (myNPbase->BrHbbRatio());
9035 dBrHXXRatio1 = BrHXXRatio - 1.0;
9036 dBrHXXRatio2 = 0.0;
9037 } else if (fstate == 4){
9038 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9039 dBrHXXRatio1 = BrHXXRatio - 1.0;
9040 dBrHXXRatio2 = 0.0;
9041 } else if (fstate == 5){
9042 BrHXXRatio = (myNPbase->BrHtautauRatio());
9043 dBrHXXRatio1 = BrHXXRatio - 1.0;
9044 dBrHXXRatio2 = 0.0;
9045 } else if (fstate == 6){
9046 BrHXXRatio = (myNPbase->BrHWWRatio());
9047 dBrHXXRatio1 = BrHXXRatio - 1.0;
9048 dBrHXXRatio2 = 0.0;
9049 } else if (fstate == 7){
9050 BrHXXRatio = (myNPbase->BrHZZRatio());
9051 dBrHXXRatio1 = BrHXXRatio - 1.0;
9052 dBrHXXRatio2 = 0.0;
9053 } else {
9054 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9055 }
9056
9057 //-- Production x Decay:
9058 if ((this->getModel()).isModelLinearized()){
9059 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9060 } else if((this->getModel()).isModelNPquadratic()){
9061 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9062 } else {
9063 return weight*(muProd)*(BrHXXRatio);
9064 }
9065
9066}
9067
9068
9069
9070
9071// -----------------------------------------------------------------------------
9072
9073
9074//VM:STXS2024;
9075STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9076: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9077{
9078 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9079 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9080
9081}
9082
9084{
9085 //-- Production:
9086 double weight = 1.0; //If normalized to the SM
9087 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9088 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9089 double muProd1 = muProd -1.0;
9090 double muProd2 = 0.0;
9091
9092 //-- Decay:
9093 double BrHXXRatio = 1.0;
9094 double dBrHXXRatio1 = 0.0;
9095 double dBrHXXRatio2 = 0.0;
9096 if (fstate==0){
9097 // Use for Cross-section [pb] with no Higgs-boson decay
9098 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9099 } else if (fstate == 1){
9100 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9101 dBrHXXRatio1 = BrHXXRatio - 1.0;
9102 dBrHXXRatio2 = 0.0;
9103 } else if (fstate == 2){
9104 BrHXXRatio = (myNPbase->BrHgagaRatio());
9105 dBrHXXRatio1 = BrHXXRatio - 1.0;
9106 dBrHXXRatio2 = 0.0;
9107 } else if (fstate == 3){
9108 BrHXXRatio = (myNPbase->BrHbbRatio());
9109 dBrHXXRatio1 = BrHXXRatio - 1.0;
9110 dBrHXXRatio2 = 0.0;
9111 } else if (fstate == 4){
9112 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9113 dBrHXXRatio1 = BrHXXRatio - 1.0;
9114 dBrHXXRatio2 = 0.0;
9115 } else if (fstate == 5){
9116 BrHXXRatio = (myNPbase->BrHtautauRatio());
9117 dBrHXXRatio1 = BrHXXRatio - 1.0;
9118 dBrHXXRatio2 = 0.0;
9119 } else if (fstate == 6){
9120 BrHXXRatio = (myNPbase->BrHWWRatio());
9121 dBrHXXRatio1 = BrHXXRatio - 1.0;
9122 dBrHXXRatio2 = 0.0;
9123 } else if (fstate == 7){
9124 BrHXXRatio = (myNPbase->BrHZZRatio());
9125 dBrHXXRatio1 = BrHXXRatio - 1.0;
9126 dBrHXXRatio2 = 0.0;
9127 } else {
9128 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9129 }
9130
9131 //-- Production x Decay:
9132 if ((this->getModel()).isModelLinearized()){
9133 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9134 } else if((this->getModel()).isModelNPquadratic()){
9135 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9136 } else {
9137 return weight*(muProd)*(BrHXXRatio);
9138 }
9139
9140}
9141
9142
9143
9144// -----------------------------------------------------------------------------
9145
9146//AG:STXS2024
9147STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9148: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9149{
9150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9151 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9152
9153}
9154
9156{
9157 //-- Production:
9158 double weight = 1.0; //If normalized to the SM
9159 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9160 double muProd1 = muProd -1.0;
9161 double muProd2 = 0.0;
9162
9163 //-- Decay:
9164 double BrHXXRatio = 1.0;
9165 double dBrHXXRatio1 = 0.0;
9166 double dBrHXXRatio2 = 0.0;
9167 if (fstate==0){
9168 // Use for Cross-section [pb] with no Higgs-boson decay
9169 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9170 } else if (fstate == 1){
9171 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9172 dBrHXXRatio1 = BrHXXRatio - 1.0;
9173 dBrHXXRatio2 = 0.0;
9174 } else if (fstate == 2){
9175 BrHXXRatio = (myNPbase->BrHgagaRatio());
9176 dBrHXXRatio1 = BrHXXRatio - 1.0;
9177 dBrHXXRatio2 = 0.0;
9178 } else if (fstate == 3){
9179 BrHXXRatio = (myNPbase->BrHbbRatio());
9180 dBrHXXRatio1 = BrHXXRatio - 1.0;
9181 dBrHXXRatio2 = 0.0;
9182 } else if (fstate == 4){
9183 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9184 dBrHXXRatio1 = BrHXXRatio - 1.0;
9185 dBrHXXRatio2 = 0.0;
9186 } else if (fstate == 5){
9187 BrHXXRatio = (myNPbase->BrHtautauRatio());
9188 dBrHXXRatio1 = BrHXXRatio - 1.0;
9189 dBrHXXRatio2 = 0.0;
9190 } else if (fstate == 6){
9191 BrHXXRatio = (myNPbase->BrHWWRatio());
9192 dBrHXXRatio1 = BrHXXRatio - 1.0;
9193 dBrHXXRatio2 = 0.0;
9194 } else if (fstate == 7){
9195 BrHXXRatio = (myNPbase->BrHZZRatio());
9196 dBrHXXRatio1 = BrHXXRatio - 1.0;
9197 dBrHXXRatio2 = 0.0;
9198 } else {
9199 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9200 }
9201
9202 //-- Production x Decay:
9203 if ((this->getModel()).isModelLinearized()){
9204 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9205 } else if((this->getModel()).isModelNPquadratic()){
9206 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9207 } else {
9208 return weight*(muProd)*(BrHXXRatio);
9209 }
9210}
9211
9212// -----------------------------------------------------------------------------
9213
9214STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9215: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9216{
9217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9218 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9219
9220}
9221
9223{
9224 double BrHXXRatio = 1.0;
9225 if (fstate == 1){
9226 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9227 } else if (fstate == 2){
9228 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9229 } else if (fstate == 3){
9230 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9231 } else if (fstate == 4){
9232 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9233 } else {
9234 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9235 }
9236
9237 if ((this->getModel()).isModelLinearized()) {
9238 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9239 } else {
9240 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9241 }
9242}
9243
9244// -----------------------------------------------------------------------------
9245
9246//AG:STXS2024
9248: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9249{
9250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9251 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9252
9253}
9254
9256{
9257 //-- Production:
9258 double weight = 1.0; //If normalized to the SM
9260 double muProd1 = muProd -1.0;
9261 double muProd2 = 0.0;
9262
9263 //-- Decay:
9264 double BrHXXRatio = 1.0;
9265 double dBrHXXRatio1 = 0.0;
9266 double dBrHXXRatio2 = 0.0;
9267 if (fstate==0){
9268 // Use for Cross-section [pb] with no Higgs-boson decay
9269 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9270 } else if (fstate == 1){
9271 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9272 dBrHXXRatio1 = BrHXXRatio - 1.0;
9273 dBrHXXRatio2 = 0.0;
9274 } else if (fstate == 2){
9275 BrHXXRatio = (myNPbase->BrHgagaRatio());
9276 dBrHXXRatio1 = BrHXXRatio - 1.0;
9277 dBrHXXRatio2 = 0.0;
9278 } else if (fstate == 3){
9279 BrHXXRatio = (myNPbase->BrHbbRatio());
9280 dBrHXXRatio1 = BrHXXRatio - 1.0;
9281 dBrHXXRatio2 = 0.0;
9282 } else if (fstate == 4){
9283 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9284 dBrHXXRatio1 = BrHXXRatio - 1.0;
9285 dBrHXXRatio2 = 0.0;
9286 } else if (fstate == 5){
9287 BrHXXRatio = (myNPbase->BrHtautauRatio());
9288 dBrHXXRatio1 = BrHXXRatio - 1.0;
9289 dBrHXXRatio2 = 0.0;
9290 } else if (fstate == 6){
9291 BrHXXRatio = (myNPbase->BrHWWRatio());
9292 dBrHXXRatio1 = BrHXXRatio - 1.0;
9293 dBrHXXRatio2 = 0.0;
9294 } else if (fstate == 7){
9295 BrHXXRatio = (myNPbase->BrHZZRatio());
9296 dBrHXXRatio1 = BrHXXRatio - 1.0;
9297 dBrHXXRatio2 = 0.0;
9298 } else {
9299 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9300 }
9301
9302
9303 //-- Production x Decay:
9304 if ((this->getModel()).isModelLinearized()){
9305 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9306 } else if((this->getModel()).isModelNPquadratic()){
9307 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9308 } else {
9309 return weight*(muProd)*(BrHXXRatio);
9310 }
9311
9312}
9313
9314// -----------------------------------------------------------------------------
9315
9317: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9318{
9319 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9320 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9321
9322}
9323
9325{
9326 double BrHXXRatio = 1.0;
9327 if (fstate == 1){
9328 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9329 } else if (fstate == 2){
9330 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9331 } else if (fstate == 3){
9332 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9333 } else if (fstate == 4){
9334 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9335 } else {
9336 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9337 }
9338
9339 if ((this->getModel()).isModelLinearized()) {
9340 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9341 } else {
9343 }
9344}
9345
9346// -----------------------------------------------------------------------------
9347
9349: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9350{
9351 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9352 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9353
9354}
9355
9357{
9358 double BrHXXRatio = 1.0;
9359 if (fstate == 1){
9360 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9361 } else if (fstate == 2){
9362 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9363 } else if (fstate == 3){
9364 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9365 } else if (fstate == 4){
9366 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9367 } else {
9368 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9369 }
9370
9371 if ((this->getModel()).isModelLinearized()) {
9372 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9373 } else {
9375 }
9376}
9377
9378// -----------------------------------------------------------------------------
9379
9381: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9382{
9383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9384 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9385
9386}
9387
9389{
9390 double BrHXXRatio = 1.0;
9391 if (fstate == 1){
9392 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9393 } else if (fstate == 2){
9394 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9395 } else if (fstate == 3){
9396 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9397 } else if (fstate == 4){
9398 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9399 } else {
9400 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9401 }
9402
9403 if ((this->getModel()).isModelLinearized()) {
9404 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9405 } else {
9407 }
9408}
9409
9410// -----------------------------------------------------------------------------
9411
9413: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9414{
9415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9416 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9417
9418}
9419
9421{
9422 double BrHXXRatio = 1.0;
9423 if (fstate == 1){
9424 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9425 } else if (fstate == 2){
9426 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9427 } else if (fstate == 3){
9428 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9429 } else if (fstate == 4){
9430 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9431 } else {
9432 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9433 }
9434
9435 if ((this->getModel()).isModelLinearized()) {
9436 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9437 } else {
9439 }
9440}
9441
9442// -----------------------------------------------------------------------------
9443
9444//AG:STXS2024
9445STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9446: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9447{
9448 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9449 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9450
9451}
9452
9454{
9455 //-- Production:
9456 double weight = 1.0; //If normalized to the SM
9458 double muProd1 = muProd -1.0;
9459 double muProd2 = 0.0;
9460
9461 //-- Decay:
9462 double BrHXXRatio = 1.0;
9463 double dBrHXXRatio1 = 0.0;
9464 double dBrHXXRatio2 = 0.0;
9465 if (fstate==0){
9466 // Use for Cross-section [pb] with no Higgs-boson decay
9467 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9468 } else if (fstate == 1){
9469 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9470 dBrHXXRatio1 = BrHXXRatio - 1.0;
9471 dBrHXXRatio2 = 0.0;
9472 } else if (fstate == 2){
9473 BrHXXRatio = (myNPbase->BrHgagaRatio());
9474 dBrHXXRatio1 = BrHXXRatio - 1.0;
9475 dBrHXXRatio2 = 0.0;
9476 } else if (fstate == 3){
9477 BrHXXRatio = (myNPbase->BrHbbRatio());
9478 dBrHXXRatio1 = BrHXXRatio - 1.0;
9479 dBrHXXRatio2 = 0.0;
9480 } else if (fstate == 4){
9481 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9482 dBrHXXRatio1 = BrHXXRatio - 1.0;
9483 dBrHXXRatio2 = 0.0;
9484 } else if (fstate == 5){
9485 BrHXXRatio = (myNPbase->BrHtautauRatio());
9486 dBrHXXRatio1 = BrHXXRatio - 1.0;
9487 dBrHXXRatio2 = 0.0;
9488 } else if (fstate == 6){
9489 BrHXXRatio = (myNPbase->BrHWWRatio());
9490 dBrHXXRatio1 = BrHXXRatio - 1.0;
9491 dBrHXXRatio2 = 0.0;
9492 } else {
9493 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9494 }
9495
9496 //-- Production x Decay:
9497 if ((this->getModel()).isModelLinearized()){
9498 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9499 } else if((this->getModel()).isModelNPquadratic()){
9500 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9501 } else {
9502 return weight*(muProd)*(BrHXXRatio);
9503 }
9504
9505
9506}
9507
9508// -----------------------------------------------------------------------------
9509
9510//AG:STXS2024
9511STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9512: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9513{
9514 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9515 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9516
9517}
9518
9520{
9521 //-- Production:
9522 double weight = 1.0; //If normalized to the SM
9524 double muProd1 = muProd -1.0;
9525 double muProd2 = 0.0;
9526
9527 //-- Decay:
9528 double BrHXXRatio = 1.0;
9529 double dBrHXXRatio1 = 0.0;
9530 double dBrHXXRatio2 = 0.0;
9531 if (fstate==0){
9532 // Use for Cross-section [pb] with no Higgs-boson decay
9533 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9534 } else if (fstate == 1){
9535 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9536 dBrHXXRatio1 = BrHXXRatio - 1.0;
9537 dBrHXXRatio2 = 0.0;
9538 } else if (fstate == 2){
9539 BrHXXRatio = (myNPbase->BrHgagaRatio());
9540 dBrHXXRatio1 = BrHXXRatio - 1.0;
9541 dBrHXXRatio2 = 0.0;
9542 } else if (fstate == 3){
9543 BrHXXRatio = (myNPbase->BrHbbRatio());
9544 dBrHXXRatio1 = BrHXXRatio - 1.0;
9545 dBrHXXRatio2 = 0.0;
9546 } else if (fstate == 4){
9547 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9548 dBrHXXRatio1 = BrHXXRatio - 1.0;
9549 dBrHXXRatio2 = 0.0;
9550 } else if (fstate == 5){
9551 BrHXXRatio = (myNPbase->BrHtautauRatio());
9552 dBrHXXRatio1 = BrHXXRatio - 1.0;
9553 dBrHXXRatio2 = 0.0;
9554 } else if (fstate == 6){
9555 BrHXXRatio = (myNPbase->BrHWWRatio());
9556 dBrHXXRatio1 = BrHXXRatio - 1.0;
9557 dBrHXXRatio2 = 0.0;
9558 } else {
9559 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9560 }
9561
9562 //-- Production x Decay:
9563 if ((this->getModel()).isModelLinearized()){
9564 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9565 } else if((this->getModel()).isModelNPquadratic()){
9566 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9567 } else {
9568 return weight*(muProd)*(BrHXXRatio);
9569 }
9570
9571
9572}
9573
9574// -----------------------------------------------------------------------------
9575
9576//AG:STXS2024
9577STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9578: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9579{
9580 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9581 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9582
9583}
9584
9586{
9587 //-- Production:
9588 double weight = 1.0; //If normalized to the SM
9590 double muProd1 = muProd -1.0;
9591 double muProd2 = 0.0;
9592
9593 //-- Decay:
9594 double BrHXXRatio = 1.0;
9595 double dBrHXXRatio1 = 0.0;
9596 double dBrHXXRatio2 = 0.0;
9597 if (fstate==0){
9598 // Use for Cross-section [pb] with no Higgs-boson decay
9599 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9600 } else if (fstate == 1){
9601 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9602 dBrHXXRatio1 = BrHXXRatio - 1.0;
9603 dBrHXXRatio2 = 0.0;
9604 } else if (fstate == 2){
9605 BrHXXRatio = (myNPbase->BrHgagaRatio());
9606 dBrHXXRatio1 = BrHXXRatio - 1.0;
9607 dBrHXXRatio2 = 0.0;
9608 } else if (fstate == 3){
9609 BrHXXRatio = (myNPbase->BrHbbRatio());
9610 dBrHXXRatio1 = BrHXXRatio - 1.0;
9611 dBrHXXRatio2 = 0.0;
9612 } else if (fstate == 4){
9613 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9614 dBrHXXRatio1 = BrHXXRatio - 1.0;
9615 dBrHXXRatio2 = 0.0;
9616 } else if (fstate == 5){
9617 BrHXXRatio = (myNPbase->BrHtautauRatio());
9618 dBrHXXRatio1 = BrHXXRatio - 1.0;
9619 dBrHXXRatio2 = 0.0;
9620 } else if (fstate == 6){
9621 BrHXXRatio = (myNPbase->BrHWWRatio());
9622 dBrHXXRatio1 = BrHXXRatio - 1.0;
9623 dBrHXXRatio2 = 0.0;
9624 } else {
9625 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9626 }
9627
9628 //-- Production x Decay:
9629 if ((this->getModel()).isModelLinearized()){
9630 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9631 } else if((this->getModel()).isModelNPquadratic()){
9632 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9633 } else {
9634 return weight*(muProd)*(BrHXXRatio);
9635 }
9636
9637
9638}
9639
9640// -----------------------------------------------------------------------------
9641
9642//AG:STXS2024
9643STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9644: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9645{
9646 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9647 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9648
9649}
9650
9652{
9653 //-- Production:
9654 double weight = 1.0; //If normalized to the SM
9656 double muProd1 = muProd -1.0;
9657 double muProd2 = 0.0;
9658
9659 //-- Decay:
9660 double BrHXXRatio = 1.0;
9661 double dBrHXXRatio1 = 0.0;
9662 double dBrHXXRatio2 = 0.0;
9663 if (fstate==0){
9664 // Use for Cross-section [pb] with no Higgs-boson decay
9665 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9666 } else if (fstate == 1){
9667 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9668 dBrHXXRatio1 = BrHXXRatio - 1.0;
9669 dBrHXXRatio2 = 0.0;
9670 } else if (fstate == 2){
9671 BrHXXRatio = (myNPbase->BrHgagaRatio());
9672 dBrHXXRatio1 = BrHXXRatio - 1.0;
9673 dBrHXXRatio2 = 0.0;
9674 } else if (fstate == 3){
9675 BrHXXRatio = (myNPbase->BrHbbRatio());
9676 dBrHXXRatio1 = BrHXXRatio - 1.0;
9677 dBrHXXRatio2 = 0.0;
9678 } else if (fstate == 4){
9679 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9680 dBrHXXRatio1 = BrHXXRatio - 1.0;
9681 dBrHXXRatio2 = 0.0;
9682 } else if (fstate == 5){
9683 BrHXXRatio = (myNPbase->BrHtautauRatio());
9684 dBrHXXRatio1 = BrHXXRatio - 1.0;
9685 dBrHXXRatio2 = 0.0;
9686 } else if (fstate == 6){
9687 BrHXXRatio = (myNPbase->BrHWWRatio());
9688 dBrHXXRatio1 = BrHXXRatio - 1.0;
9689 dBrHXXRatio2 = 0.0;
9690 } else {
9691 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9692 }
9693
9694 //-- Production x Decay:
9695 if ((this->getModel()).isModelLinearized()){
9696 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9697 } else if((this->getModel()).isModelNPquadratic()){
9698 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9699 } else {
9700 return weight*(muProd)*(BrHXXRatio);
9701 }
9702
9703}
9704
9705// -----------------------------------------------------------------------------
9706
9707//AG:STXS2024
9708STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9709: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9710{
9711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9712 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9713
9714}
9715
9717{
9718 //-- Production:
9719 double weight = 1.0; //If normalized to the SM
9720 //Since adding bins, include partial weigths of SM_predictions
9721 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9722 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9723 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9724 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9725 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9726 double muProd2 = 0.0;
9727
9728 //-- Decay:
9729 double BrHXXRatio = 1.0;
9730 double dBrHXXRatio1 = 0.0;
9731 double dBrHXXRatio2 = 0.0;
9732 if (fstate==0){
9733 // Use for Cross-section [pb] with no Higgs-boson decay
9734 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9735 } else if (fstate == 1){
9736 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9737 dBrHXXRatio1 = BrHXXRatio - 1.0;
9738 dBrHXXRatio2 = 0.0;
9739 } else if (fstate == 2){
9740 BrHXXRatio = (myNPbase->BrHgagaRatio());
9741 dBrHXXRatio1 = BrHXXRatio - 1.0;
9742 dBrHXXRatio2 = 0.0;
9743 } else if (fstate == 3){
9744 BrHXXRatio = (myNPbase->BrHbbRatio());
9745 dBrHXXRatio1 = BrHXXRatio - 1.0;
9746 dBrHXXRatio2 = 0.0;
9747 } else if (fstate == 4){
9748 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9749 dBrHXXRatio1 = BrHXXRatio - 1.0;
9750 dBrHXXRatio2 = 0.0;
9751 } else {
9752 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9753 }
9754
9755 //-- Production x Decay:
9756 if ((this->getModel()).isModelLinearized()){
9757 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9758 } else if((this->getModel()).isModelNPquadratic()){
9759 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9760 } else {
9761 return weight*(muProd)*(BrHXXRatio);
9762 }
9763
9764
9765}
9766
9767// -----------------------------------------------------------------------------
9768
9769//AG:STXS2024
9770STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9771: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9772{
9773 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9774 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9775
9776}
9777
9779{
9780 //-- Production:
9781 double weight = 1.0; //If normalized to the SM
9783 double muProd1 = muProd -1.0;
9784 double muProd2 = 0.0;
9785
9786 //-- Decay:
9787 double BrHXXRatio = 1.0;
9788 double dBrHXXRatio1 = 0.0;
9789 double dBrHXXRatio2 = 0.0;
9790 if (fstate==0){
9791 // Use for Cross-section [pb] with no Higgs-boson decay
9792 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9793 } else if (fstate == 1){
9794 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9795 dBrHXXRatio1 = BrHXXRatio - 1.0;
9796 dBrHXXRatio2 = 0.0;
9797 } else if (fstate == 2){
9798 BrHXXRatio = (myNPbase->BrHgagaRatio());
9799 dBrHXXRatio1 = BrHXXRatio - 1.0;
9800 dBrHXXRatio2 = 0.0;
9801 } else if (fstate == 3){
9802 BrHXXRatio = (myNPbase->BrHbbRatio());
9803 dBrHXXRatio1 = BrHXXRatio - 1.0;
9804 dBrHXXRatio2 = 0.0;
9805 } else if (fstate == 4){
9806 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9807 dBrHXXRatio1 = BrHXXRatio - 1.0;
9808 dBrHXXRatio2 = 0.0;
9809 } else {
9810 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9811 }
9812
9813 //-- Production x Decay:
9814 if ((this->getModel()).isModelLinearized()){
9815 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9816 } else if((this->getModel()).isModelNPquadratic()){
9817 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9818 } else {
9819 return weight*(muProd)*(BrHXXRatio);
9820 }
9821
9822
9823}
9824
9825// -----------------------------------------------------------------------------
9826
9827//AG:STXS2024
9828STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9829: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9830{
9831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9832 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9833
9834}
9835
9837{
9838 //-- Production:
9839 double weight = 1.0; //If normalized to the SM
9841 double muProd1 = muProd -1.0;
9842 double muProd2 = 0.0;
9843
9844 //-- Decay:
9845 double BrHXXRatio = 1.0;
9846 double dBrHXXRatio1 = 0.0;
9847 double dBrHXXRatio2 = 0.0;
9848 if (fstate==0){
9849 // Use for Cross-section [pb] with no Higgs-boson decay
9850 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9851 } else if (fstate == 1){
9852 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9853 dBrHXXRatio1 = BrHXXRatio - 1.0;
9854 dBrHXXRatio2 = 0.0;
9855 } else if (fstate == 2){
9856 BrHXXRatio = (myNPbase->BrHgagaRatio());
9857 dBrHXXRatio1 = BrHXXRatio - 1.0;
9858 dBrHXXRatio2 = 0.0;
9859 } else if (fstate == 3){
9860 BrHXXRatio = (myNPbase->BrHbbRatio());
9861 dBrHXXRatio1 = BrHXXRatio - 1.0;
9862 dBrHXXRatio2 = 0.0;
9863 } else if (fstate == 4){
9864 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9865 dBrHXXRatio1 = BrHXXRatio - 1.0;
9866 dBrHXXRatio2 = 0.0;
9867 } else {
9868 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9869 }
9870
9871 //-- Production x Decay:
9872 if ((this->getModel()).isModelLinearized()){
9873 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9874 } else if((this->getModel()).isModelNPquadratic()){
9875 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9876 } else {
9877 return weight*(muProd)*(BrHXXRatio);
9878 }
9879
9880
9881}
9882
9883// -----------------------------------------------------------------------------
9884
9885STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9886: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9887{
9888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9889 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9890
9891}
9892
9894{
9895 //-- Production:
9896 double weight = 1.0; //If normalized to the SM
9897 //Since adding bins, include partial weigths of SM_predictions
9898 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9899
9900 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9906 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9907
9908 double muProd1 = muProd - 1.;
9909 double muProd2 = 0.0;
9910
9911 //-- Decay:
9912 double BrHXXRatio = 1.0;
9913 double dBrHXXRatio1 = 0.0;
9914 double dBrHXXRatio2 = 0.0;
9915 if (fstate==0){
9916 // Use for Cross-section [pb] with no Higgs-boson decay
9917 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9918 } else if (fstate == 1){
9919 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9920 dBrHXXRatio1 = BrHXXRatio - 1.0;
9921 dBrHXXRatio2 = 0.0;
9922 } else if (fstate == 2){
9923 BrHXXRatio = (myNPbase->BrHgagaRatio());
9924 dBrHXXRatio1 = BrHXXRatio - 1.0;
9925 dBrHXXRatio2 = 0.0;
9926 } else if (fstate == 3){
9927 BrHXXRatio = (myNPbase->BrHbbRatio());
9928 dBrHXXRatio1 = BrHXXRatio - 1.0;
9929 dBrHXXRatio2 = 0.0;
9930 } else if (fstate == 4){
9931 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9932 dBrHXXRatio1 = BrHXXRatio - 1.0;
9933 dBrHXXRatio2 = 0.0;
9934 } else if (fstate == 5){
9935 BrHXXRatio = (myNPbase->BrHtautauRatio());
9936 dBrHXXRatio1 = BrHXXRatio - 1.0;
9937 dBrHXXRatio2 = 0.0;
9938 } else {
9939 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9940 }
9941
9942
9943
9944
9945 //-- Production x Decay:
9946 if ((this->getModel()).isModelLinearized()){
9947// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9948 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9949 } else if((this->getModel()).isModelNPquadratic()){
9950// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9951 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9952 } else {
9953// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9954 return weight*(muProd)*(BrHXXRatio);
9955 }
9956
9957}
9958
9959// -----------------------------------------------------------------------------
9960
9961STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9962: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9963{
9964 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9965 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9966
9967}
9968
9970{
9971 //-- Production:
9972 double weight = 1.0; //If normalized to the SM
9973 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9974 double muProd1 = muProd -1.0;
9975 double muProd2 = 0.0;
9976
9977 //-- Decay:
9978 double BrHXXRatio = 1.0;
9979 double dBrHXXRatio1 = 0.0;
9980 double dBrHXXRatio2 = 0.0;
9981 if (fstate==0){
9982 // Use for Cross-section [pb] with no Higgs-boson decay
9983 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9984 } else if (fstate == 1){
9985 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9986 dBrHXXRatio1 = BrHXXRatio - 1.0;
9987 dBrHXXRatio2 = 0.0;
9988 } else if (fstate == 2){
9989 BrHXXRatio = (myNPbase->BrHgagaRatio());
9990 dBrHXXRatio1 = BrHXXRatio - 1.0;
9991 dBrHXXRatio2 = 0.0;
9992 } else if (fstate == 3){
9993 BrHXXRatio = (myNPbase->BrHbbRatio());
9994 dBrHXXRatio1 = BrHXXRatio - 1.0;
9995 dBrHXXRatio2 = 0.0;
9996 } else if (fstate == 4){
9997 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9998 dBrHXXRatio1 = BrHXXRatio - 1.0;
9999 dBrHXXRatio2 = 0.0;
10000 } else if (fstate == 5){
10001 BrHXXRatio = (myNPbase->BrHtautauRatio());
10002 dBrHXXRatio1 = BrHXXRatio - 1.0;
10003 dBrHXXRatio2 = 0.0;
10004 } else {
10005 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10006 }
10007
10008 //-- Production x Decay:
10009 if ((this->getModel()).isModelLinearized()){
10010 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10011 } else if((this->getModel()).isModelNPquadratic()){
10012 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10013 } else {
10014 return weight*(muProd)*(BrHXXRatio);
10015 }
10016
10017}
10018
10019// -----------------------------------------------------------------------------
10020
10021STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10022: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10023{
10024 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10025 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10026
10027}
10028
10030{
10031 //-- Production:
10032 double weight = 1.0; //If normalized to the SM
10033 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10034 double muProd1 = muProd -1.0;
10035 double muProd2 = 0.0;
10036
10037 //-- Decay:
10038 double BrHXXRatio = 1.0;
10039 double dBrHXXRatio1 = 0.0;
10040 double dBrHXXRatio2 = 0.0;
10041 if (fstate==0){
10042 // Use for Cross-section [pb] with no Higgs-boson decay
10043 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10044 } else if (fstate == 1){
10045 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10046 dBrHXXRatio1 = BrHXXRatio - 1.0;
10047 dBrHXXRatio2 = 0.0;
10048 } else if (fstate == 2){
10049 BrHXXRatio = (myNPbase->BrHgagaRatio());
10050 dBrHXXRatio1 = BrHXXRatio - 1.0;
10051 dBrHXXRatio2 = 0.0;
10052 } else if (fstate == 3){
10053 BrHXXRatio = (myNPbase->BrHbbRatio());
10054 dBrHXXRatio1 = BrHXXRatio - 1.0;
10055 dBrHXXRatio2 = 0.0;
10056 } else if (fstate == 4){
10057 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10058 dBrHXXRatio1 = BrHXXRatio - 1.0;
10059 dBrHXXRatio2 = 0.0;
10060 } else if (fstate == 5){
10061 BrHXXRatio = (myNPbase->BrHtautauRatio());
10062 dBrHXXRatio1 = BrHXXRatio - 1.0;
10063 dBrHXXRatio2 = 0.0;
10064 } else {
10065 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10066 }
10067
10068 //-- Production x Decay:
10069 if ((this->getModel()).isModelLinearized()){
10070 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10071 } else if((this->getModel()).isModelNPquadratic()){
10072 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10073 } else {
10074 return weight*(muProd)*(BrHXXRatio);
10075 }
10076
10077}
10078
10079// -----------------------------------------------------------------------------
10080
10081//AG:STXS2024
10082STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10083: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10084{
10085 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10086 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10087
10088}
10089
10091{
10092 //-- Production:
10093 double weight = 1.0; //If normalized to the SM
10095 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10096 double muProd2 = 0.0;
10097
10098 //-- Decay:
10099 double BrHXXRatio = 1.0;
10100 double dBrHXXRatio1 = 0.0;
10101 double dBrHXXRatio2 = 0.0;
10102 if (fstate==0){
10103 // Use for Cross-section [pb] with no Higgs-boson decay
10104 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10105 } else if (fstate == 1){
10106 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10107 dBrHXXRatio1 = BrHXXRatio - 1.0;
10108 dBrHXXRatio2 = 0.0;
10109 } else if (fstate == 2){
10110 BrHXXRatio = (myNPbase->BrHgagaRatio());
10111 dBrHXXRatio1 = BrHXXRatio - 1.0;
10112 dBrHXXRatio2 = 0.0;
10113 } else if (fstate == 3){
10114 BrHXXRatio = (myNPbase->BrHbbRatio());
10115 dBrHXXRatio1 = BrHXXRatio - 1.0;
10116 dBrHXXRatio2 = 0.0;
10117 } else if (fstate == 4){
10118 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10119 dBrHXXRatio1 = BrHXXRatio - 1.0;
10120 dBrHXXRatio2 = 0.0;
10121 } else if (fstate == 5){
10122 BrHXXRatio = (myNPbase->BrHtautauRatio());
10123 dBrHXXRatio1 = BrHXXRatio - 1.0;
10124 dBrHXXRatio2 = 0.0;
10125 } else {
10126 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10127 }
10128
10129 //-- Production x Decay:
10130 if ((this->getModel()).isModelLinearized()){
10131 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10132 } else if((this->getModel()).isModelNPquadratic()){
10133 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10134 } else {
10135 return weight*(muProd)*(BrHXXRatio);
10136 }
10137
10138
10139}
10140
10141// -----------------------------------------------------------------------------
10142
10143STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10144: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10145{
10146 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10147 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10148
10149}
10150
10152{
10153 double BrHXXRatio = 1.0;
10154 if (fstate == 1){
10155 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10156 } else if (fstate == 2){
10157 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10158 } else if (fstate == 3){
10159 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10160 } else if (fstate == 4){
10161 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10162 } else {
10163 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10164 }
10165
10166 if ((this->getModel()).isModelLinearized()) {
10167 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10168 } else {
10169 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10170 }
10171}
10172
10173// -----------------------------------------------------------------------------
10174
10175STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10176: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10177{
10178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10179 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10180
10181}
10182
10184{
10185 double BrHXXRatio = 1.0;
10186 if (fstate == 1){
10187 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10188 } else if (fstate == 2){
10189 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10190 } else if (fstate == 3){
10191 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10192 } else if (fstate == 4){
10193 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10194 } else {
10195 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10196 }
10197
10198 if ((this->getModel()).isModelLinearized()) {
10199 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10200 } else {
10201 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10202 }
10203}
10204
10205// -----------------------------------------------------------------------------
10206
10207//AG:STXS2024
10208STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10209: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10210{
10211 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10212 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10213
10214}
10215
10217{
10218 //-- Production:
10219 double weight = 1.0; //If normalized to the SM
10220 //Since adding bins, include partial weigths of SM_predictions
10221 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10222 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10223 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10224 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10225 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10226 double muProd2 = 0.0;
10227
10228 //-- Decay:
10229 double BrHXXRatio = 1.0;
10230 double dBrHXXRatio1 = 0.0;
10231 double dBrHXXRatio2 = 0.0;
10232 if (fstate==0){
10233 // Use for Cross-section [pb] with no Higgs-boson decay
10234 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10235 } else if (fstate == 1){
10236 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10237 dBrHXXRatio1 = BrHXXRatio - 1.0;
10238 dBrHXXRatio2 = 0.0;
10239 } else if (fstate == 2){
10240 BrHXXRatio = (myNPbase->BrHgagaRatio());
10241 dBrHXXRatio1 = BrHXXRatio - 1.0;
10242 dBrHXXRatio2 = 0.0;
10243 } else if (fstate == 3){
10244 BrHXXRatio = (myNPbase->BrHbbRatio());
10245 dBrHXXRatio1 = BrHXXRatio - 1.0;
10246 dBrHXXRatio2 = 0.0;
10247 } else if (fstate == 4){
10248 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10249 dBrHXXRatio1 = BrHXXRatio - 1.0;
10250 dBrHXXRatio2 = 0.0;
10251 } else {
10252 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10253 }
10254
10255 //-- Production x Decay:
10256 if ((this->getModel()).isModelLinearized()){
10257 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10258 } else if((this->getModel()).isModelNPquadratic()){
10259 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10260 } else {
10261 return weight*(muProd)*(BrHXXRatio);
10262 }
10263
10264
10265}
10266
10267// -----------------------------------------------------------------------------
10268
10269//AG:STXS2024
10270STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10271: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10272{
10273 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10274 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10275
10276}
10277
10279{
10280 //-- Production:
10281 double weight = 1.0; //If normalized to the SM
10282 //Since adding bins, include partial weigths of SM_predictions
10283 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10284 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10286 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10287 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10288 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10289 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10290 double muProd2 = 0.0;
10291
10292 //-- Decay:
10293 double BrHXXRatio = 1.0;
10294 double dBrHXXRatio1 = 0.0;
10295 double dBrHXXRatio2 = 0.0;
10296 if (fstate==0){
10297 // Use for Cross-section [pb] with no Higgs-boson decay
10298 weight = 1.0 ;
10299 } else if (fstate == 1){
10300 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10301 dBrHXXRatio1 = BrHXXRatio - 1.0;
10302 dBrHXXRatio2 = 0.0;
10303 } else if (fstate == 2){
10304 BrHXXRatio = (myNPbase->BrHgagaRatio());
10305 dBrHXXRatio1 = BrHXXRatio - 1.0;
10306 dBrHXXRatio2 = 0.0;
10307 } else if (fstate == 3){
10308 BrHXXRatio = (myNPbase->BrHbbRatio());
10309 dBrHXXRatio1 = BrHXXRatio - 1.0;
10310 dBrHXXRatio2 = 0.0;
10311 } else if (fstate == 4){
10312 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10313 dBrHXXRatio1 = BrHXXRatio - 1.0;
10314 dBrHXXRatio2 = 0.0;
10315 } else {
10316 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10317 }
10318
10319 //-- Production x Decay:
10320 if ((this->getModel()).isModelLinearized()){
10321 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10322 } else if((this->getModel()).isModelNPquadratic()){
10323 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10324 } else {
10325 return weight*(muProd)*(BrHXXRatio);
10326 }
10327
10328
10329}
10330
10331// -----------------------------------------------------------------------------
10332
10333//AG:STXS2024
10334STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10335: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10336{
10337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10338 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10339
10340}
10341
10343{
10344 //-- Production:
10345 double weight = 1.0; //If normalized to the SM
10346 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10347 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10348 double muProd2 = 0.0;
10349
10350 //-- Decay:
10351 double BrHXXRatio = 1.0;
10352 double dBrHXXRatio1 = 0.0;
10353 double dBrHXXRatio2 = 0.0;
10354 if (fstate==0){
10355 // Use for Cross-section [pb] with no Higgs-boson decay
10356 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10357 } else if (fstate == 1){
10358 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10359 dBrHXXRatio1 = BrHXXRatio - 1.0;
10360 dBrHXXRatio2 = 0.0;
10361 } else if (fstate == 2){
10362 BrHXXRatio = (myNPbase->BrHgagaRatio());
10363 dBrHXXRatio1 = BrHXXRatio - 1.0;
10364 dBrHXXRatio2 = 0.0;
10365 } else if (fstate == 3){
10366 BrHXXRatio = (myNPbase->BrHbbRatio());
10367 dBrHXXRatio1 = BrHXXRatio - 1.0;
10368 dBrHXXRatio2 = 0.0;
10369 } else if (fstate == 4){
10370 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10371 dBrHXXRatio1 = BrHXXRatio - 1.0;
10372 dBrHXXRatio2 = 0.0;
10373 } else {
10374 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10375 }
10376
10377 //-- Production x Decay:
10378 if ((this->getModel()).isModelLinearized()){
10379 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10380 } else if((this->getModel()).isModelNPquadratic()){
10381 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10382 } else {
10383 return weight*(muProd)*(BrHXXRatio);
10384 }
10385
10386
10387}
10388
10389// -----------------------------------------------------------------------------
10390
10391//AG:STXS2024
10392STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10393: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10394{
10395 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10396 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10397
10398}
10399
10401{
10402 //-- Production:
10403 double weight = 1.0; //If normalized to the SM
10404 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10405 double muProd1 = muProd-1.0 ;
10406 double muProd2 = 0.0;
10407
10408 //-- Decay:
10409 double BrHXXRatio = 1.0;
10410 double dBrHXXRatio1 = 0.0;
10411 double dBrHXXRatio2 = 0.0;
10412 if (fstate==0){
10413 // Use for Cross-section [pb] with no Higgs-boson decay
10414 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10415 } else if (fstate == 1){
10416 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10417 dBrHXXRatio1 = BrHXXRatio - 1.0;
10418 dBrHXXRatio2 = 0.0;
10419 } else if (fstate == 2){
10420 BrHXXRatio = (myNPbase->BrHgagaRatio());
10421 dBrHXXRatio1 = BrHXXRatio - 1.0;
10422 dBrHXXRatio2 = 0.0;
10423 } else if (fstate == 3){
10424 BrHXXRatio = (myNPbase->BrHbbRatio());
10425 dBrHXXRatio1 = BrHXXRatio - 1.0;
10426 dBrHXXRatio2 = 0.0;
10427 } else if (fstate == 4){
10428 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10429 dBrHXXRatio1 = BrHXXRatio - 1.0;
10430 dBrHXXRatio2 = 0.0;
10431 } else {
10432 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10433 }
10434
10435 //-- Production x Decay:
10436 if ((this->getModel()).isModelLinearized()){
10437 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10438 } else if((this->getModel()).isModelNPquadratic()){
10439 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10440 } else {
10441 return weight*(muProd)*(BrHXXRatio);
10442 }
10443
10444
10445}
10446
10447
10448// -----------------------------------------------------------------------------
10449
10450STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10451: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10452{
10453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10454 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10455
10456}
10457
10459{
10460 double BrHXXRatio = 1.0;
10461 if (fstate == 1){
10462 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10463 } else if (fstate == 2){
10464 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10465 } else if (fstate == 3){
10466 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10467 } else if (fstate == 4){
10468 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10469 } else {
10470 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10471 }
10472
10473 if ((this->getModel()).isModelLinearized()) {
10474 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10475 } else {
10476 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10477 }
10478}
10479
10480// -----------------------------------------------------------------------------
10481
10482//AG:STXS2024
10483STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10484: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10485{
10486 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10487 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10488
10489}
10490
10492{
10493 //-- Production:
10494 double weight = 1.0; //If normalized to the SM
10495 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10496 double muProd1 = muProd -1.0;
10497 double muProd2 = 0.0;
10498
10499 //-- Decay:
10500 double BrHXXRatio = 1.0;
10501 double dBrHXXRatio1 = 0.0;
10502 double dBrHXXRatio2 = 0.0;
10503 if (fstate==0){
10504 // Use for Cross-section [pb] with no Higgs-boson decay
10505 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10506 } else if (fstate == 1){
10507 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10508 dBrHXXRatio1 = BrHXXRatio - 1.0;
10509 dBrHXXRatio2 = 0.0;
10510 } else if (fstate == 2){
10511 BrHXXRatio = (myNPbase->BrHgagaRatio());
10512 dBrHXXRatio1 = BrHXXRatio - 1.0;
10513 dBrHXXRatio2 = 0.0;
10514 } else if (fstate == 3){
10515 BrHXXRatio = (myNPbase->BrHbbRatio());
10516 dBrHXXRatio1 = BrHXXRatio - 1.0;
10517 dBrHXXRatio2 = 0.0;
10518 } else if (fstate == 4){
10519 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10520 dBrHXXRatio1 = BrHXXRatio - 1.0;
10521 dBrHXXRatio2 = 0.0;
10522 } else {
10523 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10524 }
10525
10526 //-- Production x Decay:
10527 if ((this->getModel()).isModelLinearized()){
10528 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10529 } else if((this->getModel()).isModelNPquadratic()){
10530 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10531 } else {
10532 return weight*(muProd)*(BrHXXRatio);
10533 }
10534
10535
10536}
10537
10538// -----------------------------------------------------------------------------
10539
10540//AG:STXS2024
10541STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10542: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10543{
10544 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10545 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10546
10547}
10548
10550{
10551 //-- Production:
10552 double weight = 1.0; //If normalized to the SM
10554 double muProd1 = muProd -1.0;
10555 double muProd2 = 0.0;
10556
10557 //-- Decay:
10558 double BrHXXRatio = 1.0;
10559 double dBrHXXRatio1 = 0.0;
10560 double dBrHXXRatio2 = 0.0;
10561 if (fstate==0){
10562 // Use for Cross-section [pb] with no Higgs-boson decay
10563 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10564 } else if (fstate == 1){
10565 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10566 dBrHXXRatio1 = BrHXXRatio - 1.0;
10567 dBrHXXRatio2 = 0.0;
10568 } else if (fstate == 2){
10569 BrHXXRatio = (myNPbase->BrHgagaRatio());
10570 dBrHXXRatio1 = BrHXXRatio - 1.0;
10571 dBrHXXRatio2 = 0.0;
10572 } else if (fstate == 3){
10573 BrHXXRatio = (myNPbase->BrHbbRatio());
10574 dBrHXXRatio1 = BrHXXRatio - 1.0;
10575 dBrHXXRatio2 = 0.0;
10576 } else if (fstate == 4){
10577 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10578 dBrHXXRatio1 = BrHXXRatio - 1.0;
10579 dBrHXXRatio2 = 0.0;
10580 } else {
10581 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10582 }
10583
10584 //-- Production x Decay:
10585 if ((this->getModel()).isModelLinearized()){
10586 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10587 } else if((this->getModel()).isModelNPquadratic()){
10588 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10589 } else {
10590 return weight*(muProd)*(BrHXXRatio);
10591 }
10592
10593}
10594
10595// -----------------------------------------------------------------------------
10596
10597STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10598: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10599{
10600 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10601 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10602
10603}
10604
10606{
10607 double BrHXXRatio = 1.0;
10608 if (fstate == 1){
10609 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10610 } else if (fstate == 2){
10611 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10612 } else if (fstate == 3){
10613 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10614 } else if (fstate == 4){
10615 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10616 } else {
10617 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10618 }
10619
10620 if ((this->getModel()).isModelLinearized()) {
10621 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10622 } else {
10623 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10624 }
10625}
10626
10627// -----------------------------------------------------------------------------
10628
10629STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10630: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10631{
10632 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10633 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10634
10635}
10636
10638{
10639 double BrHXXRatio = 1.0;
10640 if (fstate == 1){
10641 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10642 } else if (fstate == 2){
10643 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10644 } else if (fstate == 3){
10645 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10646 } else if (fstate == 4){
10647 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10648 } else {
10649 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10650 }
10651
10652 if ((this->getModel()).isModelLinearized()) {
10653 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10654 } else {
10655 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10656 }
10657}
10658
10659
10660// -----------------------------------------------------------------------------
10661
10662//AG:STXS2024
10663STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10664: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10665{
10666 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10667 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10668
10669}
10670
10672{
10673 //-- Production:
10674 double weight = 1.0; //If normalized to the SM
10675 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10676 double muProd1 = muProd -1.0;
10677 double muProd2 = 0.0;
10678
10679 //-- Decay:
10680 double BrHXXRatio = 1.0;
10681 double dBrHXXRatio1 = 0.0;
10682 double dBrHXXRatio2 = 0.0;
10683 if (fstate==0){
10684 // Use for Cross-section [pb] with no Higgs-boson decay
10685 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10686 } else if (fstate == 1){
10687 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10688 dBrHXXRatio1 = BrHXXRatio - 1.0;
10689 dBrHXXRatio2 = 0.0;
10690 } else if (fstate == 2){
10691 BrHXXRatio = (myNPbase->BrHgagaRatio());
10692 dBrHXXRatio1 = BrHXXRatio - 1.0;
10693 dBrHXXRatio2 = 0.0;
10694 } else if (fstate == 3){
10695 BrHXXRatio = (myNPbase->BrHbbRatio());
10696 dBrHXXRatio1 = BrHXXRatio - 1.0;
10697 dBrHXXRatio2 = 0.0;
10698 } else if (fstate == 4){
10699 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10700 dBrHXXRatio1 = BrHXXRatio - 1.0;
10701 dBrHXXRatio2 = 0.0;
10702 } else {
10703 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10704 }
10705
10706 //-- Production x Decay:
10707 if ((this->getModel()).isModelLinearized()){
10708 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10709 } else if((this->getModel()).isModelNPquadratic()){
10710 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10711 } else {
10712 return weight*(muProd)*(BrHXXRatio);
10713 }
10714
10715}
10716
10717// -----------------------------------------------------------------------------
10718
10719//AG:STXS2024
10720STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10721: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10722{
10723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10724 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10725
10726}
10727
10729{
10730 //-- Production:
10731 double weight = 1.0; //If normalized to the SM
10732 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10733 double muProd1 = muProd -1.0;
10734 double muProd2 = 0.0;
10735
10736 //-- Decay:
10737 double BrHXXRatio = 1.0;
10738 double dBrHXXRatio1 = 0.0;
10739 double dBrHXXRatio2 = 0.0;
10740 if (fstate==0){
10741 // Use for Cross-section [pb] with no Higgs-boson decay
10742 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10743 } else if (fstate == 1){
10744 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10745 dBrHXXRatio1 = BrHXXRatio - 1.0;
10746 dBrHXXRatio2 = 0.0;
10747 } else if (fstate == 2){
10748 BrHXXRatio = (myNPbase->BrHgagaRatio());
10749 dBrHXXRatio1 = BrHXXRatio - 1.0;
10750 dBrHXXRatio2 = 0.0;
10751 } else if (fstate == 3){
10752 BrHXXRatio = (myNPbase->BrHbbRatio());
10753 dBrHXXRatio1 = BrHXXRatio - 1.0;
10754 dBrHXXRatio2 = 0.0;
10755 } else if (fstate == 4){
10756 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10757 dBrHXXRatio1 = BrHXXRatio - 1.0;
10758 dBrHXXRatio2 = 0.0;
10759 } else {
10760 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10761 }
10762
10763 //-- Production x Decay:
10764 if ((this->getModel()).isModelLinearized()){
10765 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10766 } else if((this->getModel()).isModelNPquadratic()){
10767 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10768 } else {
10769 return weight*(muProd)*(BrHXXRatio);
10770 }
10771
10772}
10773
10774// -----------------------------------------------------------------------------
10775
10776//AG:STXS2024
10777STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10778: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10779{
10780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10781 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10782
10783}
10784
10786{
10787 //-- Production:
10788 double weight = 1.0; //If normalized to the SM
10789 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10790 double muProd1 = muProd -1.0;
10791 double muProd2 = 0.0;
10792
10793 //-- Decay:
10794 double BrHXXRatio = 1.0;
10795 double dBrHXXRatio1 = 0.0;
10796 double dBrHXXRatio2 = 0.0;
10797 if (fstate==0){
10798 // Use for Cross-section [pb] with no Higgs-boson decay
10799 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10800 } else if (fstate == 1){
10801 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10802 dBrHXXRatio1 = BrHXXRatio - 1.0;
10803 dBrHXXRatio2 = 0.0;
10804 } else if (fstate == 2){
10805 BrHXXRatio = (myNPbase->BrHgagaRatio());
10806 dBrHXXRatio1 = BrHXXRatio - 1.0;
10807 dBrHXXRatio2 = 0.0;
10808 } else if (fstate == 3){
10809 BrHXXRatio = (myNPbase->BrHbbRatio());
10810 dBrHXXRatio1 = BrHXXRatio - 1.0;
10811 dBrHXXRatio2 = 0.0;
10812 } else if (fstate == 4){
10813 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10814 dBrHXXRatio1 = BrHXXRatio - 1.0;
10815 dBrHXXRatio2 = 0.0;
10816 } else {
10817 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10818 }
10819
10820 //-- Production x Decay:
10821 if ((this->getModel()).isModelLinearized()){
10822 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10823 } else if((this->getModel()).isModelNPquadratic()){
10824 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10825 } else {
10826 return weight*(muProd)*(BrHXXRatio);
10827 }
10828
10829
10830}
10831
10832// -----------------------------------------------------------------------------
10833
10834//AG:STXS2024
10835STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10836: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10837{
10838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10839 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10840
10841}
10842
10844{
10845 //-- Production:
10846 double weight = 1.0; //If normalized to the SM
10847 //Since adding bins, include partial weigths of SM_predictions
10848 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10849 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10851 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10852 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10853 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10854 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10855 double muProd2 = 0.0;
10856
10857 //-- Decay:
10858 double BrHXXRatio = 1.0;
10859 double dBrHXXRatio1 = 0.0;
10860 double dBrHXXRatio2 = 0.0;
10861 if (fstate==0){
10862 weight = 1.0 ;
10863 } else if (fstate == 1){
10864 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10865 dBrHXXRatio1 = BrHXXRatio - 1.0;
10866 dBrHXXRatio2 = 0.0;
10867 } else if (fstate == 2){
10868 BrHXXRatio = (myNPbase->BrHgagaRatio());
10869 dBrHXXRatio1 = BrHXXRatio - 1.0;
10870 dBrHXXRatio2 = 0.0;
10871 } else if (fstate == 3){
10872 BrHXXRatio = (myNPbase->BrHbbRatio());
10873 dBrHXXRatio1 = BrHXXRatio - 1.0;
10874 dBrHXXRatio2 = 0.0;
10875 } else if (fstate == 4){
10876 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10877 dBrHXXRatio1 = BrHXXRatio - 1.0;
10878 dBrHXXRatio2 = 0.0;
10879 } else {
10880 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10881 }
10882
10883 //-- Production x Decay:
10884 if ((this->getModel()).isModelLinearized()){
10885 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10886 } else if((this->getModel()).isModelNPquadratic()){
10887 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10888 } else {
10889 return weight*(muProd)*(BrHXXRatio);
10890 }
10891
10892
10893}
10894
10895// -----------------------------------------------------------------------------
10896
10897//AG:STXS2024
10898STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10899: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10900{
10901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10902 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10903
10904}
10905
10907{
10908 //-- Production:
10909 double weight = 1.0; //If normalized to the SM
10910 //Since adding bins, include partial weigths of SM_predictions
10911 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10912 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10921 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10922 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10923 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10925 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10926 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10927 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10929 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10930 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10931 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10932 double muProd2 = 0.0;
10933
10934 //-- Decay:
10935 double BrHXXRatio = 1.0;
10936 double dBrHXXRatio1 = 0.0;
10937 double dBrHXXRatio2 = 0.0;
10938 if (fstate==0){
10939 weight = 1.0;
10940 } else if (fstate == 1){
10941 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10942 dBrHXXRatio1 = BrHXXRatio - 1.0;
10943 dBrHXXRatio2 = 0.0;
10944 } else if (fstate == 2){
10945 BrHXXRatio = (myNPbase->BrHgagaRatio());
10946 dBrHXXRatio1 = BrHXXRatio - 1.0;
10947 dBrHXXRatio2 = 0.0;
10948 } else if (fstate == 3){
10949 BrHXXRatio = (myNPbase->BrHbbRatio());
10950 dBrHXXRatio1 = BrHXXRatio - 1.0;
10951 dBrHXXRatio2 = 0.0;
10952 } else if (fstate == 4){
10953 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10954 dBrHXXRatio1 = BrHXXRatio - 1.0;
10955 dBrHXXRatio2 = 0.0;
10956 } else if (fstate == 5){
10957 BrHXXRatio = (myNPbase->BrHtautauRatio());
10958 dBrHXXRatio1 = BrHXXRatio - 1.0;
10959 dBrHXXRatio2 = 0.0;
10960 } else if (fstate == 6){
10961 BrHXXRatio = (myNPbase->BrHWWRatio());
10962 dBrHXXRatio1 = BrHXXRatio - 1.0;
10963 dBrHXXRatio2 = 0.0;
10964 } else if (fstate == 7){
10965 BrHXXRatio = (myNPbase->BrHZZRatio());
10966 dBrHXXRatio1 = BrHXXRatio - 1.0;
10967 dBrHXXRatio2 = 0.0;
10968 } else {
10969 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10970 }
10971
10972 //-- Production x Decay:
10973 if ((this->getModel()).isModelLinearized()){
10974 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10975 } else if((this->getModel()).isModelNPquadratic()){
10976 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10977 } else {
10978 return weight*(muProd)*(BrHXXRatio);
10979 }
10980
10981
10982}
10983
10984// -----------------------------------------------------------------------------
10985
10986//AG:STXS2024
10987STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10988: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10989{
10990 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10991 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10992
10993}
10994
10996{
10997 //-- Production:
10998 double weight = 1.0; //If normalized to the SM
10999 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
11000 double muProd1 = muProd -1.0;
11001 double muProd2 = 0.0;
11002
11003 //-- Decay:
11004 double BrHXXRatio = 1.0;
11005 double dBrHXXRatio1 = 0.0;
11006 double dBrHXXRatio2 = 0.0;
11007 if (fstate==0){
11008 // Use for Cross-section [pb] with no Higgs-boson decay
11009 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11010 } else if (fstate == 1){
11011 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11012 dBrHXXRatio1 = BrHXXRatio - 1.0;
11013 dBrHXXRatio2 = 0.0;
11014 } else if (fstate == 2){
11015 BrHXXRatio = (myNPbase->BrHgagaRatio());
11016 dBrHXXRatio1 = BrHXXRatio - 1.0;
11017 dBrHXXRatio2 = 0.0;
11018 } else if (fstate == 3){
11019 BrHXXRatio = (myNPbase->BrHbbRatio());
11020 dBrHXXRatio1 = BrHXXRatio - 1.0;
11021 dBrHXXRatio2 = 0.0;
11022 } else if (fstate == 4){
11023 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11024 dBrHXXRatio1 = BrHXXRatio - 1.0;
11025 dBrHXXRatio2 = 0.0;
11026 } else {
11027 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
11028 }
11029
11030 //-- Production x Decay:
11031 if ((this->getModel()).isModelLinearized()){
11032 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11033 } else if((this->getModel()).isModelNPquadratic()){
11034 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11035 } else {
11036 return weight*(muProd)*(BrHXXRatio);
11037 }
11038
11039
11040}
11041
11042// -----------------------------------------------------------------------------
11043
11044//AG:STXS2024
11045STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11046: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11047{
11048 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11049 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
11050
11051}
11052
11054{
11055 //-- Production:
11056 double weight = 1.0; //If normalized to the SM
11057 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
11058 double muProd1 = muProd -1.0;
11059 double muProd2 = 0.0;
11060
11061 //-- Decay:
11062 double BrHXXRatio = 1.0;
11063 double dBrHXXRatio1 = 0.0;
11064 double dBrHXXRatio2 = 0.0;
11065 if (fstate==0){
11066 // Use for Cross-section [pb] with no Higgs-boson decay
11067 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11068 } else if (fstate == 1){
11069 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11070 dBrHXXRatio1 = BrHXXRatio - 1.0;
11071 dBrHXXRatio2 = 0.0;
11072 } else if (fstate == 2){
11073 BrHXXRatio = (myNPbase->BrHgagaRatio());
11074 dBrHXXRatio1 = BrHXXRatio - 1.0;
11075 dBrHXXRatio2 = 0.0;
11076 } else if (fstate == 3){
11077 BrHXXRatio = (myNPbase->BrHbbRatio());
11078 dBrHXXRatio1 = BrHXXRatio - 1.0;
11079 dBrHXXRatio2 = 0.0;
11080 } else if (fstate == 4){
11081 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11082 dBrHXXRatio1 = BrHXXRatio - 1.0;
11083 dBrHXXRatio2 = 0.0;
11084 } else {
11085 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11086 }
11087
11088 //-- Production x Decay:
11089 if ((this->getModel()).isModelLinearized()){
11090 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11091 } else if((this->getModel()).isModelNPquadratic()){
11092 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11093 } else {
11094 return weight*(muProd)*(BrHXXRatio);
11095 }
11096
11097}
11098
11099// -----------------------------------------------------------------------------
11100
11101//AG:STXS2024
11102STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11103: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11104{
11105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11106 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11107
11108}
11109
11111{
11112 //-- Production:
11113 double weight = 1.0; //If normalized to the SM
11114 //Since adding bins, include partial weigths of SM_predictions
11115 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11116 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11117 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11118 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11119 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11120 double muProd2 = 0.0;
11121
11122 //-- Decay:
11123 double BrHXXRatio = 1.0;
11124 double dBrHXXRatio1 = 0.0;
11125 double dBrHXXRatio2 = 0.0;
11126 if (fstate==0){
11127 // Use for Cross-section [pb] with no Higgs-boson decay
11128 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11129 } else if (fstate == 1){
11130 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11131 dBrHXXRatio1 = BrHXXRatio - 1.0;
11132 dBrHXXRatio2 = 0.0;
11133 } else if (fstate == 2){
11134 BrHXXRatio = (myNPbase->BrHgagaRatio());
11135 dBrHXXRatio1 = BrHXXRatio - 1.0;
11136 dBrHXXRatio2 = 0.0;
11137 } else if (fstate == 3){
11138 BrHXXRatio = (myNPbase->BrHbbRatio());
11139 dBrHXXRatio1 = BrHXXRatio - 1.0;
11140 dBrHXXRatio2 = 0.0;
11141 } else if (fstate == 4){
11142 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11143 dBrHXXRatio1 = BrHXXRatio - 1.0;
11144 dBrHXXRatio2 = 0.0;
11145 } else {
11146 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11147 }
11148
11149 //-- Production x Decay:
11150 if ((this->getModel()).isModelLinearized()){
11151 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11152 } else if((this->getModel()).isModelNPquadratic()){
11153 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11154 } else {
11155 return weight*(muProd)*(BrHXXRatio);
11156 }
11157
11158}
11159
11160// -----------------------------------------------------------------------------
11161
11162//AG:STXS2024
11163STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11164: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11165{
11166 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11167 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11168
11169}
11170
11172{
11173 //-- Production:
11174 double weight = 1.0; //If normalized to the SM
11175 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11176 double muProd1 = muProd -1.0;
11177 double muProd2 = 0.0;
11178
11179 //-- Decay:
11180 double BrHXXRatio = 1.0;
11181 double dBrHXXRatio1 = 0.0;
11182 double dBrHXXRatio2 = 0.0;
11183 if (fstate==0){
11184 // Use for Cross-section [pb] with no Higgs-boson decay
11185 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11186 } else if (fstate == 1){
11187 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11188 dBrHXXRatio1 = BrHXXRatio - 1.0;
11189 dBrHXXRatio2 = 0.0;
11190 } else if (fstate == 2){
11191 BrHXXRatio = (myNPbase->BrHgagaRatio());
11192 dBrHXXRatio1 = BrHXXRatio - 1.0;
11193 dBrHXXRatio2 = 0.0;
11194 } else if (fstate == 3){
11195 BrHXXRatio = (myNPbase->BrHbbRatio());
11196 dBrHXXRatio1 = BrHXXRatio - 1.0;
11197 dBrHXXRatio2 = 0.0;
11198 } else if (fstate == 4){
11199 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11200 dBrHXXRatio1 = BrHXXRatio - 1.0;
11201 dBrHXXRatio2 = 0.0;
11202 } else {
11203 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11204 }
11205
11206 //-- Production x Decay:
11207 if ((this->getModel()).isModelLinearized()){
11208 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11209 } else if((this->getModel()).isModelNPquadratic()){
11210 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11211 } else {
11212 return weight*(muProd)*(BrHXXRatio);
11213 }
11214
11215}
11216
11217// -----------------------------------------------------------------------------
11218
11219//AG:STXS2024
11220STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11221: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11222{
11223 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11224 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11225
11226}
11227
11229{
11230 //-- Production:
11231 double weight = 1.0; //If normalized to the SM
11232 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11233 double muProd1 = muProd -1.0;
11234 double muProd2 = 0.0;
11235
11236 //-- Decay:
11237 double BrHXXRatio = 1.0;
11238 double dBrHXXRatio1 = 0.0;
11239 double dBrHXXRatio2 = 0.0;
11240 if (fstate==0){
11241 // Use for Cross-section [pb] with no Higgs-boson decay
11242 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11243 } else if (fstate == 1){
11244 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11245 dBrHXXRatio1 = BrHXXRatio - 1.0;
11246 dBrHXXRatio2 = 0.0;
11247 } else if (fstate == 2){
11248 BrHXXRatio = (myNPbase->BrHgagaRatio());
11249 dBrHXXRatio1 = BrHXXRatio - 1.0;
11250 dBrHXXRatio2 = 0.0;
11251 } else if (fstate == 3){
11252 BrHXXRatio = (myNPbase->BrHbbRatio());
11253 dBrHXXRatio1 = BrHXXRatio - 1.0;
11254 dBrHXXRatio2 = 0.0;
11255 } else if (fstate == 4){
11256 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11257 dBrHXXRatio1 = BrHXXRatio - 1.0;
11258 dBrHXXRatio2 = 0.0;
11259 } else {
11260 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11261 }
11262
11263 //-- Production x Decay:
11264 if ((this->getModel()).isModelLinearized()){
11265 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11266 } else if((this->getModel()).isModelNPquadratic()){
11267 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11268 } else {
11269 return weight*(muProd)*(BrHXXRatio);
11270 }
11271
11272}
11273
11274// -----------------------------------------------------------------------------
11275
11276STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11277: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11278{
11279 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11280 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11281
11282}
11283
11285{
11286 //-- Production:
11287 double weight = 1.0; //If normalized to the SM
11288 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11289 double muProd1 = muProd -1.0;
11290 double muProd2 = 0.0;
11291
11292 //-- Decay:
11293 double BrHXXRatio = 1.0;
11294 double dBrHXXRatio1 = 0.0;
11295 double dBrHXXRatio2 = 0.0;
11296 if (fstate==0){
11297 // Use for Cross-section [pb] with no Higgs-boson decay
11298 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11299 } else if (fstate == 1){
11300 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11301 dBrHXXRatio1 = BrHXXRatio - 1.0;
11302 dBrHXXRatio2 = 0.0;
11303 } else if (fstate == 2){
11304 BrHXXRatio = (myNPbase->BrHgagaRatio());
11305 dBrHXXRatio1 = BrHXXRatio - 1.0;
11306 dBrHXXRatio2 = 0.0;
11307 } else if (fstate == 3){
11308 BrHXXRatio = (myNPbase->BrHbbRatio());
11309 dBrHXXRatio1 = BrHXXRatio - 1.0;
11310 dBrHXXRatio2 = 0.0;
11311 } else if (fstate == 4){
11312 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11313 dBrHXXRatio1 = BrHXXRatio - 1.0;
11314 dBrHXXRatio2 = 0.0;
11315 } else {
11316 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11317 }
11318
11319 //-- Production x Decay:
11320 if ((this->getModel()).isModelLinearized()){
11321 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11322 } else if((this->getModel()).isModelNPquadratic()){
11323 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11324 } else {
11325 return weight*(muProd)*(BrHXXRatio);
11326 }
11327
11328
11329}
11330
11331// -----------------------------------------------------------------------------
11332
11333//AG:STXS2024
11334STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11335: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11336{
11337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11338 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11339
11340}
11341
11343{
11344 //-- Production:
11345 double weight = 1.0; //If normalized to the SM
11346 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11347 double muProd1 = muProd -1.0;
11348 double muProd2 = 0.0;
11349
11350 //-- Decay:
11351 double BrHXXRatio = 1.0;
11352 double dBrHXXRatio1 = 0.0;
11353 double dBrHXXRatio2 = 0.0;
11354 if (fstate==0){
11355 // Use for Cross-section [pb] with no Higgs-boson decay
11356 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11357 } else if (fstate == 1){
11358 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11359 dBrHXXRatio1 = BrHXXRatio - 1.0;
11360 dBrHXXRatio2 = 0.0;
11361 } else if (fstate == 2){
11362 BrHXXRatio = (myNPbase->BrHgagaRatio());
11363 dBrHXXRatio1 = BrHXXRatio - 1.0;
11364 dBrHXXRatio2 = 0.0;
11365 } else if (fstate == 3){
11366 BrHXXRatio = (myNPbase->BrHbbRatio());
11367 dBrHXXRatio1 = BrHXXRatio - 1.0;
11368 dBrHXXRatio2 = 0.0;
11369 } else if (fstate == 4){
11370 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11371 dBrHXXRatio1 = BrHXXRatio - 1.0;
11372 dBrHXXRatio2 = 0.0;
11373 } else if (fstate == 5){
11374 BrHXXRatio = (myNPbase->BrHtautauRatio());
11375 dBrHXXRatio1 = BrHXXRatio - 1.0;
11376 dBrHXXRatio2 = 0.0;
11377 } else {
11378 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11379 }
11380
11381 //-- Production x Decay:
11382 if ((this->getModel()).isModelLinearized()){
11383 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11384 } else if((this->getModel()).isModelNPquadratic()){
11385 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11386 } else {
11387 return weight*(muProd)*(BrHXXRatio);
11388 }
11389
11390}
11391// -----------------------------------------------------------------------------
11392
11393//AG:STXS2024
11394STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11395: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11396{
11397 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11398 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11399
11400}
11401
11403{
11404 //-- Production:
11405 double weight = 1.0; //If normalized to the SM
11406 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11407 double muProd1 = muProd -1.0;
11408 double muProd2 = 0.0;
11409
11410 //-- Decay:
11411 double BrHXXRatio = 1.0;
11412 double dBrHXXRatio1 = 0.0;
11413 double dBrHXXRatio2 = 0.0;
11414 if (fstate==0){
11415 // Use for Cross-section [pb] with no Higgs-boson decay
11416 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11417 } else if (fstate == 1){
11418 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11419 dBrHXXRatio1 = BrHXXRatio - 1.0;
11420 dBrHXXRatio2 = 0.0;
11421 } else if (fstate == 2){
11422 BrHXXRatio = (myNPbase->BrHgagaRatio());
11423 dBrHXXRatio1 = BrHXXRatio - 1.0;
11424 dBrHXXRatio2 = 0.0;
11425 } else if (fstate == 3){
11426 BrHXXRatio = (myNPbase->BrHbbRatio());
11427 dBrHXXRatio1 = BrHXXRatio - 1.0;
11428 dBrHXXRatio2 = 0.0;
11429 } else if (fstate == 4){
11430 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11431 dBrHXXRatio1 = BrHXXRatio - 1.0;
11432 dBrHXXRatio2 = 0.0;
11433 } else if (fstate == 5){
11434 BrHXXRatio = (myNPbase->BrHtautauRatio());
11435 dBrHXXRatio1 = BrHXXRatio - 1.0;
11436 dBrHXXRatio2 = 0.0;
11437 } else {
11438 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11439 }
11440
11441 //-- Production x Decay:
11442 if ((this->getModel()).isModelLinearized()){
11443 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11444 } else if((this->getModel()).isModelNPquadratic()){
11445 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11446 } else {
11447 return weight*(muProd)*(BrHXXRatio);
11448 }
11449
11450}
11451
11452// -----------------------------------------------------------------------------
11453
11454//AG:STXS2024
11455STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11456: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11457{
11458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11459 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11460
11461}
11462
11464{
11465 //-- Production:
11466 double weight = 1.0; //If normalized to the SM
11467 //Since adding bins, include partial weigths of SM_predictions
11468 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11469 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11470 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11471 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11472 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11473 double muProd2 = 0.0;
11474
11475 //-- Decay:
11476 double BrHXXRatio = 1.0;
11477 double dBrHXXRatio1 = 0.0;
11478 double dBrHXXRatio2 = 0.0;
11479 if (fstate==0){
11480 // Use for Cross-section [pb] with no Higgs-boson decay
11481 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11482 } else if (fstate == 1){
11483 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11484 dBrHXXRatio1 = BrHXXRatio - 1.0;
11485 dBrHXXRatio2 = 0.0;
11486 } else if (fstate == 2){
11487 BrHXXRatio = (myNPbase->BrHgagaRatio());
11488 dBrHXXRatio1 = BrHXXRatio - 1.0;
11489 dBrHXXRatio2 = 0.0;
11490 } else if (fstate == 3){
11491 BrHXXRatio = (myNPbase->BrHbbRatio());
11492 dBrHXXRatio1 = BrHXXRatio - 1.0;
11493 dBrHXXRatio2 = 0.0;
11494 } else if (fstate == 4){
11495 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11496 dBrHXXRatio1 = BrHXXRatio - 1.0;
11497 dBrHXXRatio2 = 0.0;
11498 } else if (fstate == 5){
11499 BrHXXRatio = (myNPbase->BrHtautauRatio());
11500 dBrHXXRatio1 = BrHXXRatio - 1.0;
11501 dBrHXXRatio2 = 0.0;
11502 } else {
11503 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11504 }
11505
11506 //-- Production x Decay:
11507 if ((this->getModel()).isModelLinearized()){
11508 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11509 } else if((this->getModel()).isModelNPquadratic()){
11510 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11511 } else {
11512 return weight*(muProd)*(BrHXXRatio);
11513 }
11514
11515}
11516
11517// -----------------------------------------------------------------------------
11518
11519//AG:STXS2024
11520STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11521: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11522{
11523 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11524 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11525
11526}
11527
11529{
11530 //-- Production:
11531 double weight = 1.0; //If normalized to the SM
11532 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11533 //Since adding bins, include partial weigths (SM_predictions)
11534 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11539 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11540 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11541 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11542 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11543 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11544 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11545 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11546 double muProd2 = 0.0;
11547
11548 //-- Decay:
11549 double BrHXXRatio = 1.0;
11550 double dBrHXXRatio1 = 0.0;
11551 double dBrHXXRatio2 = 0.0;
11552 if (fstate==0){
11553 weight = 1.0;
11554 } else if (fstate == 1){
11555 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11556 dBrHXXRatio1 = BrHXXRatio - 1.0;
11557 dBrHXXRatio2 = 0.0;
11558 } else if (fstate == 2){
11559 BrHXXRatio = (myNPbase->BrHgagaRatio());
11560 dBrHXXRatio1 = BrHXXRatio - 1.0;
11561 dBrHXXRatio2 = 0.0;
11562 } else if (fstate == 3){
11563 BrHXXRatio = (myNPbase->BrHbbRatio());
11564 dBrHXXRatio1 = BrHXXRatio - 1.0;
11565 dBrHXXRatio2 = 0.0;
11566 } else if (fstate == 4){
11567 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11568 dBrHXXRatio1 = BrHXXRatio - 1.0;
11569 dBrHXXRatio2 = 0.0;
11570 } else if (fstate == 5){
11571 BrHXXRatio = (myNPbase->BrHtautauRatio());
11572 dBrHXXRatio1 = BrHXXRatio - 1.0;
11573 dBrHXXRatio2 = 0.0;
11574 } else if (fstate == 6){
11575 BrHXXRatio = (myNPbase->BrHWWRatio());
11576 dBrHXXRatio1 = BrHXXRatio - 1.0;
11577 dBrHXXRatio2 = 0.0;
11578 } else if (fstate == 7){
11579 BrHXXRatio = (myNPbase->BrHZZRatio());
11580 dBrHXXRatio1 = BrHXXRatio - 1.0;
11581 dBrHXXRatio2 = 0.0;
11582 } else {
11583 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11584 }
11585
11586 //-- Production x Decay:
11587 if ((this->getModel()).isModelLinearized()){
11588 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11589 } else if((this->getModel()).isModelNPquadratic()){
11590 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11591 } else {
11592 return weight*(muProd)*(BrHXXRatio);
11593 }
11594
11595}
11596
11597// -----------------------------------------------------------------------------
11598
11599//AG:STXS2024
11600STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11601: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11602{
11603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11604 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11605
11606}
11607
11608double STXS12_tH::computeThValue() //AG:modified
11609{
11610 //-- Production:
11611 double weight = 1.0; //If normalized to the SM
11612 double muProd = myNPbase->STXS12_tH(sqrt_s);
11613 double muProd1 = muProd -1.0;
11614 double muProd2 = 0.0;
11615
11616 //-- Decay:
11617 double BrHXXRatio = 1.0;
11618 double dBrHXXRatio1 = 0.0;
11619 double dBrHXXRatio2 = 0.0;
11620 if (fstate==0){
11621 // Use for Cross-section [pb] with no Higgs-boson decay
11622 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11623 } else if (fstate == 1){
11624 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11625 dBrHXXRatio1 = BrHXXRatio - 1.0;
11626 dBrHXXRatio2 = 0.0;
11627 } else if (fstate == 2){
11628 BrHXXRatio = (myNPbase->BrHgagaRatio());
11629 dBrHXXRatio1 = BrHXXRatio - 1.0;
11630 dBrHXXRatio2 = 0.0;
11631 } else if (fstate == 3){
11632 BrHXXRatio = (myNPbase->BrHbbRatio());
11633 dBrHXXRatio1 = BrHXXRatio - 1.0;
11634 dBrHXXRatio2 = 0.0;
11635 } else if (fstate == 4){
11636 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11637 dBrHXXRatio1 = BrHXXRatio - 1.0;
11638 dBrHXXRatio2 = 0.0;
11639 } else if (fstate == 5){
11640 BrHXXRatio = (myNPbase->BrHtautauRatio());
11641 dBrHXXRatio1 = BrHXXRatio - 1.0;
11642 dBrHXXRatio2 = 0.0;
11643 } else {
11644 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11645 }
11646
11647 //-- Production x Decay:
11648 if ((this->getModel()).isModelLinearized()){
11649 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11650 } else if((this->getModel()).isModelNPquadratic()){
11651 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11652 } else {
11653 return weight*(muProd)*(BrHXXRatio);
11654 }
11655
11656
11657}
11658
11659// -----------------------------------------------------------------------------
11660
11661
11662//-----------------------------------------------------------------------------------------
11663//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11664//-----------------------------------------------------------------------------------------
11665
11666
11667muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11668: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11669{
11670 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11671 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11672}
11673
11675{
11676 return myNPbase->muTHUggHgaga(sqrt_s);
11677}
11678
11679
11680muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11681: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11682{
11683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11684 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11685}
11686
11688{
11689 return myNPbase->muTHUVBFHgaga(sqrt_s);
11690}
11691
11692muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11694{
11695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11696 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11697}
11698
11700{
11701 return myNPbase->muTHUZHgaga(sqrt_s);
11702}
11703
11704muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11705: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11706{
11707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11708 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11709}
11710
11712{
11713 return myNPbase->muTHUWHgaga(sqrt_s);
11714}
11715
11716muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11717: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11718{
11719 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11720 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11721}
11722
11724{
11725 return myNPbase->muTHUVHgaga(sqrt_s);
11726}
11727
11728muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11729: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11730{
11731 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11732 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11733}
11734
11736{
11737 return myNPbase->muTHUttHgaga(sqrt_s);
11738}
11739
11740muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11741: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11742{
11743 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11744 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11745}
11746
11748{
11749 return myNPbase->muTHUggHZga(sqrt_s);
11750}
11751
11752muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11753: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11754{
11755 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11756 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11757}
11758
11760{
11761 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11762}
11763
11764muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11765: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11766{
11767 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11768 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11769}
11770
11772{
11773
11774 return myNPbase->muTHUVBFHZga(sqrt_s);
11775}
11776
11777muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11778: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11779{
11780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11781 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11782}
11783
11785{
11786 return myNPbase->muTHUZHZga(sqrt_s);
11787}
11788
11789muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11790: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11791{
11792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11793 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11794}
11795
11797{
11798 return myNPbase->muTHUWHZga(sqrt_s);
11799}
11800
11801muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11802: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11803{
11804 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11805 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11806}
11807
11809{
11810 return myNPbase->muTHUVHZga(sqrt_s);
11811}
11812
11813muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11814: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11815{
11816 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11817 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11818}
11819
11821{
11822 return myNPbase->muTHUttHZga(sqrt_s);
11823}
11824
11825muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11826: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11827{
11828 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11829 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11830}
11831
11833{
11834 return myNPbase->muTHUggHZZ(sqrt_s);
11835}
11836
11837muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11838: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11839{
11840 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11841 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11842}
11843
11845{
11846 return myNPbase->muTHUVBFHZZ(sqrt_s);
11847}
11848
11849muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11850: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11851{
11852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11853 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11854}
11855
11857{
11858 return myNPbase->muTHUZHZZ(sqrt_s);
11859}
11860
11861muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11862: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11863{
11864 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11865 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11866}
11867
11869{
11870 return myNPbase->muTHUWHZZ(sqrt_s);
11871}
11872
11873muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11874: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11875{
11876 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11877 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11878}
11879
11881{
11882 return myNPbase->muTHUVHZZ(sqrt_s);
11883}
11884
11885muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11886: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11887{
11888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11889 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11890}
11891
11893{
11894 return myNPbase->muTHUttHZZ(sqrt_s);
11895}
11896
11897muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11898: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11899{
11900 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11901 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11902}
11903
11905{
11906 return myNPbase->muTHUggHZZ4l(sqrt_s);
11907}
11908
11909muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11910: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11911{
11912 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11913 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11914}
11915
11917{
11918 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11919}
11920
11921muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11922: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11923{
11924 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11925 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11926}
11927
11929{
11930 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11931}
11932
11933muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11934: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11935{
11936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11937 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11938}
11939
11941{
11942 return myNPbase->muTHUZHZZ4l(sqrt_s);
11943}
11944
11945muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11946: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11947{
11948 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11949 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11950}
11951
11953{
11954 return myNPbase->muTHUWHZZ4l(sqrt_s);
11955}
11956
11957muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11958: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11959{
11960 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11961 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11962}
11963
11965{
11966 return myNPbase->muTHUVHZZ4l(sqrt_s);
11967}
11968
11969muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11970: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11971{
11972 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11973 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11974}
11975
11977{
11978 return myNPbase->muTHUttHZZ4l(sqrt_s);
11979}
11980
11981muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11982: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11983{
11984 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11985 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11986}
11987
11989{
11990 return myNPbase->muTHUggHWW(sqrt_s);
11991}
11992
11993muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11994: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11995{
11996 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11997 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11998}
11999
12001{
12002 return myNPbase->muTHUVBFHWW(sqrt_s);
12003}
12004
12005muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
12006: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12007{
12008 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12009 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
12010}
12011
12013{
12014 return myNPbase->muTHUZHWW(sqrt_s);
12015}
12016
12017muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
12018: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12019{
12020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12021 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
12022}
12023
12025{
12026 return myNPbase->muTHUWHWW(sqrt_s);
12027}
12028
12029muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
12030: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12031{
12032 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12033 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
12034}
12035
12037{
12038 return myNPbase->muTHUVHWW(sqrt_s);
12039}
12040
12041muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
12042: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12043{
12044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12045 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
12046}
12047
12049{
12050 return myNPbase->muTHUttHWW(sqrt_s);
12051}
12052
12053muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12054: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12055{
12056 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12057 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
12058}
12059
12061{
12063}
12064
12065muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12066: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12067{
12068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12069 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
12070}
12071
12073{
12075}
12076
12077muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12078: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12079{
12080 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12081 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12082}
12083
12085{
12086 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12087}
12088
12089muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12090: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12091{
12092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12093 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12094}
12095
12097{
12098 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12099}
12100
12101muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12102: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12103{
12104 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12105 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12106}
12107
12109{
12110 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12111}
12112
12113muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12114: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12115{
12116 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12117 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12118}
12119
12121{
12123}
12124
12125muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12126: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12127{
12128 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12129 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12130}
12131
12133{
12134 return myNPbase->muTHUggHmumu(sqrt_s);
12135}
12136
12137muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12138: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12139{
12140 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12141 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12142}
12143
12145{
12146 return myNPbase->muTHUVBFHmumu(sqrt_s);
12147}
12148
12149muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12150: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12151{
12152 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12153 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12154}
12155
12157{
12158 return myNPbase->muTHUZHmumu(sqrt_s);
12159}
12160
12161muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12162: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12163{
12164 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12165 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12166}
12167
12169{
12170 return myNPbase->muTHUWHmumu(sqrt_s);
12171}
12172
12173muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12175{
12176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12177 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12178}
12179
12181{
12182 return myNPbase->muTHUVHmumu(sqrt_s);
12183}
12184
12185muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12187{
12188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12189 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12190}
12191
12193{
12194 return myNPbase->muTHUttHmumu(sqrt_s);
12195}
12196
12197muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12198: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12199{
12200 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12201 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12202}
12203
12205{
12207}
12208
12209muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12210: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12211{
12212 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12213 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12214}
12215
12217{
12219}
12220
12221muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12222: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12223{
12224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12225 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12226}
12227
12229{
12230 return myNPbase->muTHUZHtautau(sqrt_s);
12231}
12232
12233muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12234: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12235{
12236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12237 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12238}
12239
12241{
12242 return myNPbase->muTHUWHtautau(sqrt_s);
12243}
12244
12245muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12246: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12247{
12248 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12249 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12250}
12251
12253{
12254 return myNPbase->muTHUVHtautau(sqrt_s);
12255}
12256
12257muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12258: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12259{
12260 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12261 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12262}
12263
12265{
12267}
12268
12269muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12270: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12271{
12272 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12273 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12274}
12275
12277{
12278 return myNPbase->muTHUggHbb(sqrt_s);
12279}
12280
12281muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12282: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12283{
12284 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12285 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12286}
12287
12289{
12290 return myNPbase->muTHUVBFHbb(sqrt_s);
12291}
12292
12293muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12295{
12296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12297 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12298}
12299
12301{
12302 return myNPbase->muTHUZHbb(sqrt_s);
12303}
12304
12305muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12306: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12307{
12308 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12309 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12310}
12311
12313{
12314 return myNPbase->muTHUWHbb(sqrt_s);
12315}
12316
12317muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12318: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12319{
12320 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12321 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12322}
12323
12325{
12326 return myNPbase->muTHUVHbb(sqrt_s);
12327}
12328
12329muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12330: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12331{
12332 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12333 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12334}
12335
12337{
12338 return myNPbase->muTHUttHbb(sqrt_s);
12339}
12340
12341
12342muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12343: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12344{
12345 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12346 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12347}
12348
12350{
12351
12352 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12353
12354}
12355
12356muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12357: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12358{
12359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12360 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12361}
12362
12364{
12365
12366 return (myNPbase->muTHUVBFHinv(sqrt_s));
12367
12368}
12369
12370
12371muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12372: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12373{
12374 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12375 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12376}
12377
12379{
12380
12381 return (myNPbase->muTHUVHBRinv(sqrt_s));
12382
12383}
12384
12385muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12386: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12387{
12388 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12389 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12390}
12391
12393{
12394 return (myNPbase->muTHUVHinv(sqrt_s));
12395}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1660
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1584
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3712
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3317
virtual const double cbminuscc() const
Definition: NPbase.h:2506
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2692
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3987
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:1841
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4077
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2179
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:972
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3608
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2656
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2582
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2287
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:2752
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3723
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1455
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3097
virtual const double cVpluscb() const
Definition: NPbase.h:2488
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:1845
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3617
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1204
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1564
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:947
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3784
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3870
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3702
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3143
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1764
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1239
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:923
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1929
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3816
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1344
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1022
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3192
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1380
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1531
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1471
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1632
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2594
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3346
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1600
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3969
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3494
virtual const double ccminusctau() const
Definition: NPbase.h:2524
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2606
virtual const double mueeZH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1103
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3861
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3222
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1596
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4104
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1511
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1737
virtual const double cgaplusct() const
Definition: NPbase.h:2470
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:2757
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2566
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:1827
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1056
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1588
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3134
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4086
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:3806
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1919
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1284
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3825
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:2767
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1760
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2546
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2586
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2590
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3503
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3766
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1620
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3879
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3915
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2660
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3172
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3942
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1487
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2636
virtual const double cgplusct() const
Definition: NPbase.h:2461
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1652
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3457
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2562
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1296
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:2740
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3735
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1544
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1552
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4023
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1459
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1572
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:1859
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1091
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3590
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3470
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3906
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3430
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2080
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2044
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2022
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1397
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1692
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1153
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3530
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1415
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3326
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:1939
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1818
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3512
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:1832
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3978
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4014
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3385
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3336
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:2744
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3366
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2627
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1696
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:2772
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2366
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1755
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1463
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:1836
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3116
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1576
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1560
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1499
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4131
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1814
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1787
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2554
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3212
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1483
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3356
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1067
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3653
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1796
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2652
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3421
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1909
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3231
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1467
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:2728
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1624
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1507
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2676
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1309
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3521
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2416
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2558
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2296
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3087
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1592
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:985
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1568
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1656
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4140
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1672
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:1863
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3757
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3308
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1580
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3748
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3680
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3403
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3439
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1640
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2542
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1809
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2648
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1805
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1403
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2672
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3644
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1166
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3558
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2012
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1439
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2452
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2317
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3240
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1443
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3478
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3268
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2386
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4149
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1889
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3662
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1515
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1320
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1332
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3152
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3691
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1969
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1668
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3834
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:997
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3125
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2425
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2688
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3635
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4032
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:2777
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:1877
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3671
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:2720
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2615
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1548
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3843
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3888
virtual const double cbminusctau() const
Definition: NPbase.h:2515
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2348
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1228
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2089
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:960
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2631
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1523
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2434
virtual const double mueeZHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1140
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2680
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3775
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1010
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3626
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2377
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1409
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1676
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1556
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2602
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:912
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3182
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1392
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3202
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2623
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3394
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1800
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1644
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2708
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3569
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3924
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1949
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3412
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2233
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:2762
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1664
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2537
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1680
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4095
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2611
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1451
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:2732
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2550
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1604
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1491
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1503
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:1823
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1045
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4167
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1495
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2396
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1628
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1612
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3581
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1479
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2339
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2640
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3951
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3288
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4050
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2406
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3486
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2002
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1636
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:2748
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1192
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1216
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3107
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:3795
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4059
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1272
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:2782
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3162
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3548
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1356
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3960
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1648
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2188
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1475
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2716
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1982
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1435
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3852
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3599
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2443
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2570
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1899
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2664
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1959
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1115
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1733
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1608
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3376
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2700
virtual const double cgminuscga() const
Definition: NPbase.h:2479
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3075
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1710
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2598
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3897
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:2724
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1078
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1700
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3259
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3278
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:935
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1430
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2357
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:901
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1791
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4158
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1536
virtual const double cVplusctau() const
Definition: NPbase.h:2497
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2668
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3448
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1034
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1724
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2712
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1540
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4041
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1728
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1684
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1527
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2574
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1250
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4113
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1179
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:2736
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2696
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3996
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1127
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3298
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2619
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4068
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1616
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1447
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1688
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2704
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4122
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3250
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1992
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2684
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1519
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3539
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2644
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1368
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3933
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2578
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeZHBRinvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double Pol_em
const double sqrt_s
const double Pol_ep
mueeZHWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
mueeZHZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const double Pol_ep
mueeZHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZHccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZHgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double Pol_em
mueeZHggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
mueeZHinvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double Pol_ep
mueeZHssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeZHtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase